* @{
*/
+static int
+first_type_in_signature (const DBusString *str,
+ int pos)
+{
+ int t;
+
+ t = _dbus_string_get_byte (str, pos);
+
+ if (t == DBUS_STRUCT_BEGIN_CHAR)
+ return DBUS_TYPE_STRUCT;
+ else
+ return t;
+}
+
+static int
+element_type_get_alignment (const DBusString *str,
+ int pos)
+{
+ return _dbus_type_get_alignment (first_type_in_signature (str, pos));
+}
+
void
_dbus_type_reader_init (DBusTypeReader *reader,
int byte_order,
reader->type_pos = type_pos;
reader->value_str = value_str;
reader->value_pos = value_pos;
+ reader->container_type = DBUS_TYPE_INVALID;
- _dbus_verbose ("type reader %p init type_pos = %d value_pos = %d remaining sig '%s'\n",
+ _dbus_verbose (" type reader %p init type_pos = %d value_pos = %d remaining sig '%s'\n",
reader, reader->type_pos, reader->value_pos,
_dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0));
}
{
int t;
- t = _dbus_string_get_byte (reader->type_str,
- reader->type_pos);
+ /* for INVALID t will == DBUS_TYPE_INVALID when we
+ * reach the end of type_str, for STRUCT we have to
+ * check the finished flag
+ */
+ if (reader->container_type == DBUS_TYPE_INVALID)
+ {
+ t = first_type_in_signature (reader->type_str,
+ reader->type_pos);
+ }
+ else if (reader->container_type == DBUS_TYPE_STRUCT)
+ {
+ if (reader->u.strct.finished)
+ t = DBUS_TYPE_INVALID;
+ else
+ t = first_type_in_signature (reader->type_str,
+ reader->type_pos);
+ }
+ else if (reader->container_type == DBUS_TYPE_ARRAY)
+ {
+ /* return the array element type if elements remain, and
+ * TYPE_INVALID otherwise
+ */
+ int end_pos;
- if (t == DBUS_STRUCT_BEGIN_CHAR)
- t = DBUS_TYPE_STRUCT;
+ end_pos = reader->u.array.start_pos + reader->u.array.len;
- /* this should never be a stopping place */
- _dbus_assert (t != DBUS_STRUCT_END_CHAR);
+ _dbus_assert (reader->value_pos <= end_pos);
+ _dbus_assert (reader->value_pos >= reader->u.array.start_pos);
+
+ if (reader->value_pos < end_pos)
+ t = reader->u.array.element_type;
+ else
+ t = DBUS_TYPE_INVALID;
+ }
+ else
+ {
+ _dbus_assert_not_reached ("reader->container_type should not be set to this");
+ t = DBUS_TYPE_INVALID; /* quiet gcc */
+ }
+ _dbus_assert (t != DBUS_STRUCT_END_CHAR);
+ _dbus_assert (t != DBUS_STRUCT_BEGIN_CHAR);
+
#if 0
- _dbus_verbose ("type reader %p current type_pos = %d type = %s\n",
+ _dbus_verbose (" type reader %p current type_pos = %d type = %s\n",
reader, reader->type_pos,
_dbus_type_to_string (t));
#endif
}
int
-_dbus_type_reader_get_array_type (DBusTypeReader *reader)
+_dbus_type_reader_get_array_length (DBusTypeReader *reader)
{
- int t;
-
- t = _dbus_type_reader_get_current_type (reader);
-
- if (t != DBUS_TYPE_ARRAY)
- return DBUS_TYPE_INVALID;
-
- t = _dbus_string_get_byte (reader->type_str,
- reader->type_pos + 1);
-
- return t;
+ /* FIXME if this is in number of elements I don't know how to compute it
+ * since we only have bytes and elements are variable-length
+ */
}
void
_dbus_type_reader_read_basic (DBusTypeReader *reader,
void *value)
{
- int t;
- int next;
-
- t = _dbus_type_reader_get_current_type (reader);
+ if (reader->container_type == DBUS_TYPE_INVALID ||
+ reader->container_type == DBUS_TYPE_STRUCT ||
+ reader->container_type == DBUS_TYPE_ARRAY)
+ {
+ int t;
+ int next;
+
+ t = _dbus_type_reader_get_current_type (reader);
- next = reader->value_pos;
- _dbus_demarshal_basic_type (reader->value_str,
- t, value,
- reader->byte_order,
- &next);
+ next = reader->value_pos;
+ _dbus_demarshal_basic_type (reader->value_str,
+ t, value,
+ reader->byte_order,
+ &next);
- _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));
+ _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
+ {
+ _dbus_assert_not_reached ("reader->container_type should not be set to this");
+ }
}
dbus_bool_t
{
int t;
- t = _dbus_string_get_byte (reader->type_str, reader->type_pos);
+ /* FIXME are we recursing over the type signature or over the values.
+ * Arrays don't necessarily have values for each element of the type
+ * signature. Thus we get a mismatch where we need to "bail out" and
+ * return the signature of each element, but can't return an element
+ * or recurse into the element signature. Not sure how to handle this;
+ * maybe think about how we will handle variant types and do something
+ * similar since they also have the idea of a signature for the whole
+ * sub-item?
+ */
+
+ t = first_type_in_signature (reader->type_str, reader->type_pos);
/* point subreader at the same place as reader */
_dbus_type_reader_init (sub,
reader->value_str,
reader->value_pos);
- _dbus_assert (t == DBUS_STRUCT_BEGIN_CHAR); /* only this works right now */
-
- sub->type_pos += 1;
+ if (t == DBUS_TYPE_STRUCT)
+ {
+ sub->container_type = DBUS_TYPE_STRUCT;
+
+ sub->type_pos += 1;
+
+ /* struct has 8 byte alignment */
+ sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 8);
+
+ sub->u.strct.finished = FALSE;
+ }
+ else if (t == DBUS_TYPE_ARRAY)
+ {
+ dbus_uint32_t array_len;
+ int alignment;
+
+ sub->container_type = DBUS_TYPE_ARRAY;
+
+ /* point type_pos at the array element type */
+ sub->type_pos += 1;
+
+ sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 4);
+
+ _dbus_demarshal_basic_type (sub->value_str,
+ DBUS_TYPE_UINT32,
+ &array_len,
+ sub->byte_order,
+ &sub->value_pos);
+
+ sub->u.array.len = array_len;
+
+ alignment = element_type_get_alignment (sub->type_str,
+ sub->type_pos);
+
+ sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, alignment);
+
+ sub->u.array.element_type = first_type_in_signature (sub->type_str,
+ sub->type_pos);
+ sub->u.array.start_pos = sub->value_pos;
- /* no value_pos increment since the struct itself doesn't take up value space */
+ _dbus_verbose (" type reader %p array start = %d array len = %d array element type = %s\n",
+ reader,
+ sub->u.array.start_pos,
+ sub->u.array.len,
+ _dbus_type_to_string (sub->u.array.element_type));
+ }
+ else
+ {
+ _dbus_verbose ("recursing into type %s\n", _dbus_type_to_string (t));
+ if (t == DBUS_TYPE_INVALID)
+ _dbus_warn ("You can't recurse into an empty array or off the end of a message body\n");
+
+ _dbus_assert_not_reached ("don't yet handle recursing into this type");
+ }
- _dbus_verbose ("type reader %p recursed type_pos = %d value_pos = %d remaining sig '%s'\n",
+ _dbus_verbose (" type reader %p RECURSED type_pos = %d value_pos = %d remaining sig '%s'\n",
sub, sub->type_pos, sub->value_pos,
_dbus_string_get_const_data_len (sub->type_str, sub->type_pos, 0));
}
+static void
+skip_one_complete_type (const DBusString *type_str,
+ int *type_pos)
+{
+ while (_dbus_string_get_byte (type_str, *type_pos) == DBUS_TYPE_ARRAY)
+ *type_pos += 1;
+
+ if (_dbus_string_get_byte (type_str, *type_pos) == DBUS_STRUCT_BEGIN_CHAR)
+ {
+ int depth;
+ depth = 1;
+ *type_pos += 1;
+ while (depth > 0)
+ {
+ switch (_dbus_string_get_byte (type_str, *type_pos))
+ {
+ case DBUS_STRUCT_BEGIN_CHAR:
+ depth += 1;
+ break;
+ case DBUS_STRUCT_END_CHAR:
+ depth -= 1;
+ break;
+ case DBUS_TYPE_INVALID:
+ _dbus_assert_not_reached ("unbalanced parens in signature");
+ break;
+ }
+ *type_pos += 1;
+ }
+ }
+ else
+ *type_pos += 1;
+}
+
/**
* Skip to the next value on this "level". e.g. the next field in a
* struct, the next value in an array, the next key or value in a
_dbus_type_reader_next (DBusTypeReader *reader)
{
int t;
-
- /* FIXME handled calling next when there's no next */
- t = _dbus_string_get_byte (reader->type_str, reader->type_pos);
+ t = _dbus_type_reader_get_current_type (reader);
- _dbus_verbose ("type reader %p next() { type_pos = %d value_pos = %d remaining sig '%s'\n",
+ _dbus_verbose (" type reader %p START next() { type_pos = %d value_pos = %d remaining sig '%s' current_type = %s\n",
reader, reader->type_pos, reader->value_pos,
- _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0));
+ _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0),
+ _dbus_type_to_string (t));
+
+ if (t == DBUS_TYPE_INVALID)
+ return FALSE;
- switch (t)
+ if (reader->container_type == DBUS_TYPE_INVALID ||
+ reader->container_type == DBUS_TYPE_STRUCT)
{
- case DBUS_STRUCT_BEGIN_CHAR:
- /* Scan forward over the entire container contents */
- {
- DBusTypeReader sub;
-
- /* Recurse into the struct */
- _dbus_type_reader_recurse (reader, &sub);
-
- /* Skip everything in this subreader */
- while (_dbus_type_reader_next (&sub))
+ switch (t)
+ {
+ case DBUS_TYPE_STRUCT:
+ case DBUS_TYPE_ARRAY:
+ /* Scan forward over the entire container contents */
+ /* FIXME this is super slow for arrays. We need to special
+ * case skipping all the elements at once instead of scanning.
+ */
{
- /* nothing */;
- }
+ DBusTypeReader sub;
- /* Now we are at the end of this container */
- reader->type_pos = sub.type_pos;
- reader->value_pos = sub.value_pos;
- }
- break;
+ /* Recurse into the struct */
+ _dbus_type_reader_recurse (reader, &sub);
- default:
- /* FIXME for array etc. this is more complicated */
- _dbus_marshal_skip_basic_type (reader->value_str,
- t, reader->byte_order,
- &reader->value_pos);
- reader->type_pos += 1;
- break;
- }
-
- _dbus_verbose ("type reader %p } type_pos = %d value_pos = %d remaining sig '%s'\n",
- reader, reader->type_pos, reader->value_pos,
- _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0));
-
- /* FIXME this is wrong; we need to return FALSE when we finish the
- * container we've recursed into; even if the signature continues.
- */
-
- t = _dbus_string_get_byte (reader->type_str, reader->type_pos);
+ /* Skip everything in this subreader */
+ while (_dbus_type_reader_next (&sub))
+ {
+ /* nothing */;
+ }
- if (t == DBUS_STRUCT_END_CHAR)
+ /* Now we are at the end of this container */
+ reader->type_pos = sub.type_pos;
+ reader->value_pos = sub.value_pos;
+ }
+ break;
+
+ default:
+ _dbus_marshal_skip_basic_type (reader->value_str,
+ t, reader->byte_order,
+ &reader->value_pos);
+ reader->type_pos += 1;
+ break;
+ }
+
+ /* for STRUCT containers we return FALSE at the end of the struct,
+ * for INVALID we return FALSE at the end of the signature.
+ * In both cases we arrange for get_current_type() to return INVALID
+ * which is defined to happen iff we're at the end (no more next())
+ */
+ if (reader->container_type == DBUS_TYPE_STRUCT)
+ {
+ t = _dbus_string_get_byte (reader->type_str, reader->type_pos);
+ if (t == DBUS_STRUCT_END_CHAR)
+ {
+ reader->type_pos += 1;
+ reader->u.strct.finished = TRUE;
+ }
+ }
+ }
+ else if (reader->container_type == DBUS_TYPE_ARRAY)
{
- reader->type_pos += 1;
- return FALSE;
+ /* Skip one array element */
+ int end_pos;
+
+ end_pos = reader->u.array.start_pos + reader->u.array.len;
+
+ _dbus_assert (reader->value_pos < end_pos);
+ _dbus_assert (reader->value_pos >= reader->u.array.start_pos);
+
+ if (reader->u.array.element_type == DBUS_TYPE_ARRAY ||
+ reader->u.array.element_type == DBUS_TYPE_STRUCT)
+ {
+ DBusTypeReader sub;
+
+ /* Recurse into the array element */
+ _dbus_type_reader_recurse (reader, &sub);
+
+ /* Skip everything in this element */
+ while (_dbus_type_reader_next (&sub))
+ {
+ /* nothing */;
+ }
+
+ /* Now we are at the end of this element */
+ reader->value_pos = sub.value_pos;
+ }
+ else
+ {
+ _dbus_marshal_skip_basic_type (reader->value_str,
+ t, reader->byte_order,
+ &reader->value_pos);
+ }
+
+ _dbus_assert (reader->value_pos <= end_pos);
+
+ if (reader->value_pos == end_pos)
+ {
+ skip_one_complete_type (reader->type_str,
+ &reader->type_pos);
+ }
+ }
+ else
+ {
+ _dbus_assert_not_reached ("reader->container_type should not be set to this");
}
- if (t == DBUS_TYPE_INVALID)
- return FALSE;
- return TRUE;
+ _dbus_verbose (" type reader %p END next() type_pos = %d value_pos = %d remaining sig '%s' current_type = %s\n",
+ reader, reader->type_pos, reader->value_pos,
+ _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0),
+ _dbus_type_to_string (_dbus_type_reader_get_current_type (reader)));
+
+ return _dbus_type_reader_get_current_type (reader) != DBUS_TYPE_INVALID;
}
void
writer->value_str = value_str;
writer->value_pos = value_pos;
writer->container_type = DBUS_TYPE_INVALID;
+ writer->inside_array = FALSE;
+}
+
+static dbus_bool_t
+_dbus_type_writer_write_basic_no_typecode (DBusTypeWriter *writer,
+ int type,
+ const void *value)
+{
+ int old_value_len;
+ int bytes_written;
+
+ old_value_len = _dbus_string_get_length (writer->value_str);
+
+ if (!_dbus_marshal_basic_type (writer->value_str,
+ writer->value_pos,
+ type,
+ value,
+ writer->byte_order))
+ return FALSE;
+
+ bytes_written = _dbus_string_get_length (writer->value_str) - old_value_len;
+
+ writer->value_pos += bytes_written;
+
+ return TRUE;
}
dbus_bool_t
const void *value)
{
dbus_bool_t retval;
- int old_value_len;
-
- old_value_len = _dbus_string_get_length (writer->value_str);
/* First ensure that our type realloc will succeed */
if (!_dbus_string_alloc_space (writer->type_str, 1))
return FALSE;
retval = FALSE;
-
- if (!_dbus_marshal_basic_type (writer->value_str,
- writer->value_pos,
- type,
- value,
- writer->byte_order))
- goto out;
- writer->value_pos += _dbus_string_get_length (writer->value_str) - old_value_len;
+ if (!_dbus_type_writer_write_basic_no_typecode (writer, type, value))
+ goto out;
- /* Now insert the type */
- 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;
+ /* 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_recurse (DBusTypeWriter *writer,
- int container_type,
- DBusTypeWriter *sub)
+static void
+writer_recurse_init_and_check (DBusTypeWriter *writer,
+ int container_type,
+ const char *array_element_type,
+ DBusTypeWriter *sub)
{
_dbus_type_writer_init (sub,
writer->byte_order,
writer->type_pos,
writer->value_str,
writer->value_pos);
+
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 ((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));
+ }
+
+ if (sub->container_type == DBUS_TYPE_ARRAY)
+ {
+ 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);
+ }
+ }
+ }
+#endif /* DBUS_DISABLE_CHECKS */
+
+ _dbus_verbose (" type writer %p recurse 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 new sub type_pos = %d value_pos = %d inside_array = %d container_type = %s element_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_bool_t
+_dbus_type_writer_recurse (DBusTypeWriter *writer,
+ int container_type,
+ DBusTypeWriter *sub)
+{
+ writer_recurse_init_and_check (writer, container_type, NULL, sub);
switch (container_type)
{
case DBUS_TYPE_STRUCT:
{
- if (!_dbus_string_insert_byte (sub->type_str,
- sub->type_pos,
- DBUS_STRUCT_BEGIN_CHAR))
- return FALSE;
+ 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;
+ }
- sub->type_pos += 1;
+ if (!_dbus_string_insert_bytes (sub->value_str,
+ sub->value_pos,
+ _DBUS_ALIGN_VALUE (sub->value_pos, 8) - sub->value_pos,
+ '\0'))
+ _dbus_assert_not_reached ("should not have failed to insert alignment padding for struct");
+ sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 8);
}
break;
+ case DBUS_TYPE_ARRAY:
+ _dbus_assert_not_reached ("use recurse_array() for arrays");
+ break;
default:
_dbus_assert_not_reached ("container_type unhandled");
break;
}
dbus_bool_t
+_dbus_type_writer_recurse_array (DBusTypeWriter *writer,
+ const char *element_type,
+ DBusTypeWriter *sub)
+{
+ int element_type_len;
+ DBusString element_type_str;
+
+ writer_recurse_init_and_check (writer, DBUS_TYPE_ARRAY, element_type, sub);
+
+ _dbus_string_init_const (&element_type_str, element_type);
+ element_type_len = _dbus_string_get_length (&element_type_str);
+
+ /* 4 bytes for the array length and 4 bytes possible padding */
+ if (!_dbus_string_alloc_space (sub->value_str, 8))
+ return FALSE;
+
+ if (!writer->inside_array)
+ {
+ /* 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))
+ 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,
+ DBUS_TYPE_ARRAY))
+ _dbus_assert_not_reached ("should not have failed to insert array typecode");
+
+ sub->type_pos += 1;
+
+ if (!_dbus_string_copy (&element_type_str, 0,
+ sub->type_str, sub->type_pos))
+ _dbus_assert_not_reached ("should not have failed to insert array element typecodes");
+
+ sub->type_pos += element_type_len;
+ }
+
+ sub->u.array.len_pos = sub->value_pos;
+
+ {
+ 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_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 */
+
+ return TRUE;
+}
+
+dbus_bool_t
_dbus_type_writer_unrecurse (DBusTypeWriter *writer,
DBusTypeWriter *sub)
{
_dbus_assert (sub->type_pos > 0); /* can't be recursed if this fails */
+ _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",
+ 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");
+
if (sub->container_type == DBUS_TYPE_STRUCT)
{
- if (!_dbus_string_insert_byte (sub->type_str,
- sub->type_pos,
- DBUS_STRUCT_END_CHAR))
- return FALSE;
- sub->type_pos += 1;
+ 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;
+ }
+ }
+ 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;
+ _dbus_marshal_set_uint32 (sub->value_str,
+ sub->byte_order,
+ sub->u.array.len_pos,
+ len);
+ _dbus_verbose (" filled in sub array len to %u at len_pos %d\n",
+ len, sub->u.array.len_pos);
}
/* Jump the parent writer to the new location */
return TRUE;
}
+static dbus_bool_t
+write_array_of_int32 (DataBlock *block,
+ DBusTypeWriter *writer)
+{
+ dbus_int32_t v;
+ DataBlockState saved;
+ DBusTypeWriter sub;
+
+ data_block_save (block, &saved);
+
+ if (!_dbus_type_writer_recurse_array (writer,
+ DBUS_TYPE_INT32_AS_STRING,
+ &sub))
+ return FALSE;
+
+ v = SAMPLE_INT32_ALTERNATE;
+ if (!_dbus_type_writer_write_basic (&sub,
+ DBUS_TYPE_INT32,
+ &v))
+ {
+ data_block_restore (block, &saved);
+ return FALSE;
+ }
+
+ v = SAMPLE_INT32;
+ if (!_dbus_type_writer_write_basic (&sub,
+ DBUS_TYPE_INT32,
+ &v))
+ {
+ data_block_restore (block, &saved);
+ return FALSE;
+ }
+
+ v = SAMPLE_INT32;
+ if (!_dbus_type_writer_write_basic (&sub,
+ DBUS_TYPE_INT32,
+ &v))
+ {
+ 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_int32 (DataBlock *block,
+ DBusTypeReader *reader)
+{
+ dbus_int32_t v;
+ DBusTypeReader sub;
+
+ check_expected_type (reader, DBUS_TYPE_ARRAY);
+
+ _dbus_type_reader_recurse (reader, &sub);
+
+ check_expected_type (&sub, DBUS_TYPE_INT32);
+
+ _dbus_type_reader_read_basic (&sub,
+ (dbus_int32_t*) &v);
+
+ _dbus_assert (v == SAMPLE_INT32_ALTERNATE);
+
+ _dbus_type_reader_next (&sub);
+ check_expected_type (&sub, DBUS_TYPE_INT32);
+
+ _dbus_type_reader_read_basic (&sub,
+ (dbus_int32_t*) &v);
+
+ _dbus_assert (v == SAMPLE_INT32);
+
+ _dbus_type_reader_next (&sub);
+ check_expected_type (&sub, DBUS_TYPE_INT32);
+
+ _dbus_type_reader_read_basic (&sub,
+ (dbus_int32_t*) &v);
+
+ _dbus_assert (v == SAMPLE_INT32);
+
+ return TRUE;
+}
+
+
+static dbus_bool_t
+write_array_of_int32_empty (DataBlock *block,
+ DBusTypeWriter *writer)
+{
+ DataBlockState saved;
+ DBusTypeWriter sub;
+
+ data_block_save (block, &saved);
+
+ if (!_dbus_type_writer_recurse_array (writer,
+ DBUS_TYPE_INT32_AS_STRING,
+ &sub))
+ 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_int32_empty (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_INVALID);
+
+ return TRUE;
+}
+
+static dbus_bool_t
+write_array_of_array_of_int32 (DataBlock *block,
+ DBusTypeWriter *writer)
+{
+ DataBlockState saved;
+ DBusTypeWriter sub;
+
+ data_block_save (block, &saved);
+
+ if (!_dbus_type_writer_recurse_array (writer,
+ DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_INT32_AS_STRING,
+ &sub))
+ return FALSE;
+
+ if (!write_array_of_int32 (block, &sub))
+ {
+ data_block_restore (block, &saved);
+ 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 (!write_array_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_array_of_int32 (DataBlock *block,
+ DBusTypeReader *reader)
+{
+ DBusTypeReader sub;
+
+ check_expected_type (reader, DBUS_TYPE_ARRAY);
+
+ _dbus_type_reader_recurse (reader, &sub);
+
+ if (!read_array_of_int32 (block, &sub))
+ return FALSE;
+ _dbus_type_reader_next (&sub);
+ if (!read_array_of_int32 (block, &sub))
+ return FALSE;
+ _dbus_type_reader_next (&sub);
+ if (!read_array_of_int32_empty (block, &sub))
+ return FALSE;
+ _dbus_type_reader_next (&sub);
+ if (!read_array_of_int32 (block, &sub))
+ return FALSE;
+ _dbus_type_reader_next (&sub);
+
+ return TRUE;
+}
+
+
+static dbus_bool_t
+write_array_of_array_of_int32_empty (DataBlock *block,
+ DBusTypeWriter *writer)
+{
+ DataBlockState saved;
+ DBusTypeWriter sub;
+
+ data_block_save (block, &saved);
+
+ if (!_dbus_type_writer_recurse_array (writer,
+ DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_INT32_AS_STRING,
+ &sub))
+ 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_array_of_int32_empty (DataBlock *block,
+ DBusTypeReader *reader)
+{
+ DBusTypeReader sub;
+ DBusTypeReader sub2;
+
+ check_expected_type (reader, DBUS_TYPE_ARRAY);
+
+ _dbus_type_reader_recurse (reader, &sub);
+
+ check_expected_type (reader, DBUS_TYPE_ARRAY);
+
+ _dbus_type_reader_recurse (&sub, &sub2);
+
+ check_expected_type (reader, DBUS_TYPE_INVALID);
+
+ return TRUE;
+}
+
+static dbus_bool_t
+write_array_of_array_of_array_of_int32 (DataBlock *block,
+ DBusTypeWriter *writer)
+{
+ DataBlockState saved;
+ DBusTypeWriter sub;
+
+ data_block_save (block, &saved);
+
+ if (!_dbus_type_writer_recurse_array (writer,
+ DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_INT32_AS_STRING,
+ &sub))
+ return FALSE;
+
+ if (!write_array_of_array_of_int32 (block, &sub))
+ {
+ data_block_restore (block, &saved);
+ return FALSE;
+ }
+
+ if (!write_array_of_array_of_int32 (block, &sub))
+ {
+ data_block_restore (block, &saved);
+ return FALSE;
+ }
+
+ if (!write_array_of_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_array_of_array_of_array_of_int32 (DataBlock *block,
+ DBusTypeReader *reader)
+{
+ DBusTypeReader sub;
+
+ check_expected_type (reader, DBUS_TYPE_ARRAY);
+
+ _dbus_type_reader_recurse (reader, &sub);
+
+ if (!read_array_of_array_of_int32 (block, &sub))
+ return FALSE;
+ _dbus_type_reader_next (&sub);
+ if (!read_array_of_array_of_int32 (block, &sub))
+ return FALSE;
+ _dbus_type_reader_next (&sub);
+ if (!read_array_of_array_of_int32_empty (block, &sub))
+ return FALSE;
+ _dbus_type_reader_next (&sub);
+
+ return TRUE;
+}
+
typedef enum {
ITEM_INVALID = -1,
ITEM_INT32 = 0,
ITEM_STRUCT_WITH_INT32S,
ITEM_STRUCT_OF_STRUCTS,
ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS,
+ ITEM_ARRAY_OF_INT32,
+ ITEM_ARRAY_OF_INT32_EMPTY,
+ ITEM_ARRAY_OF_ARRAY_OF_INT32,
+ ITEM_ARRAY_OF_ARRAY_OF_INT32_EMPTY,
+ ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32,
ITEM_LAST
} WhichItem;
{ "struct of two structs of three structs of two int32",
ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS,
write_struct_of_structs_of_structs,
- read_struct_of_structs_of_structs }
+ read_struct_of_structs_of_structs },
+ { "array of int32",
+ ITEM_ARRAY_OF_INT32, write_array_of_int32, read_array_of_int32 },
+ { "empty array of int32",
+ ITEM_ARRAY_OF_INT32_EMPTY, write_array_of_int32_empty, read_array_of_int32_empty },
+ { "array of array of int32",
+ ITEM_ARRAY_OF_ARRAY_OF_INT32,
+ write_array_of_array_of_int32, read_array_of_array_of_int32 },
+ { "empty array of array of int32",
+ ITEM_ARRAY_OF_ARRAY_OF_INT32_EMPTY,
+ 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 }
};
typedef struct
{
- /* Array of items in the above items[]; -1 terminated */
+ /* Array of items from the above items[]; -1 terminated */
int items[20];
} TestRun;
{ { 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_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_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INVALID } },
+
+ /* ARRAY_OF_INT32 */
+ { { ITEM_ARRAY_OF_INT32, ITEM_INVALID } },
+ { { ITEM_ARRAY_OF_INT32, ITEM_ARRAY_OF_INT32, ITEM_INVALID } },
+ { { ITEM_ARRAY_OF_INT32, ITEM_ARRAY_OF_INT32, ITEM_ARRAY_OF_INT32, ITEM_INVALID } },
+ { { ITEM_ARRAY_OF_INT32, ITEM_ARRAY_OF_INT32, ITEM_ARRAY_OF_INT32, ITEM_INT32, ITEM_INVALID } },
+ { { ITEM_ARRAY_OF_INT32, ITEM_INT32, 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_ARRAY_OF_INT32, ITEM_INT32, ITEM_ARRAY_OF_INT32, ITEM_INVALID } },
+
+ /* ARRAY_OF_ARRAY_OF_INT32 */
+ { { ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_INVALID } },
+ { { ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_INVALID } },
+ { { ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_INVALID } },
+ { { ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_INT32, ITEM_INVALID } },
+ { { ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_INT32, ITEM_INVALID } },
+ { { 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_ARRAY_OF_ARRAY_OF_INT32, ITEM_INT32, ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_INVALID } },
+
+ /* 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_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_INVALID } },
+ { { ITEM_ARRAY_OF_ARRAY_OF_ARRAY_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_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_INT32, ITEM_INVALID } },
+ { { ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_INT32, ITEM_INVALID } },
+ { { 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 } }
+
};
retval = FALSE;
+ {
+ _dbus_verbose ("run byteorder %s items ",
+ byte_order == DBUS_LITTLE_ENDIAN ? "little" : "big");
+ i = 0;
+ while (run->items[i] != ITEM_INVALID)
+ {
+ CheckMarshalItem *item = &items[run->items[i]];
+
+ _dbus_verbose ("%s ", item->desc);
+ ++i;
+ }
+ _dbus_verbose (" = %d items\n", i);
+ }
+
data_block_save (block, &saved);
data_block_init_reader_writer (block,
{
CheckMarshalItem *item = &items[run->items[i]];
- _dbus_verbose ("writing %s\n", item->desc);
+ _dbus_verbose (">>writing %s\n", item->desc);
if (!(* item->write_item_func) (block, &writer))
goto out;
{
CheckMarshalItem *item = &items[run->items[i]];
- _dbus_verbose ("reading %s\n", item->desc);
+ _dbus_verbose (">>reading %s\n", item->desc);
if (!(* item->read_item_func) (block, &reader))
goto out;
projects / platform / upstream / dbus.git / commitdiff