return t;
}
-int
-_dbus_type_reader_get_array_length (DBusTypeReader *reader)
+dbus_bool_t
+_dbus_type_reader_array_is_empty (DBusTypeReader *reader)
{
- /* 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
- */
+ dbus_uint32_t array_len;
+ int len_pos;
+
+ _dbus_return_val_if_fail (_dbus_type_reader_get_current_type (reader) == DBUS_TYPE_ARRAY,
+ TRUE);
+
+ len_pos = _DBUS_ALIGN_VALUE (reader->value_pos, 4);
+
+ _dbus_demarshal_basic_type (reader->value_str,
+ DBUS_TYPE_UINT32,
+ &array_len,
+ reader->byte_order,
+ &len_pos);
+
+ return array_len == 0;
}
void
* Initialize a new reader pointing to the first type and
* corresponding value that's a child of the current container. It's
* an error to call this if the current type is a non-container.
+ *
+ * Note that DBusTypeReader traverses values, not types. So if you
+ * have an empty array of array of int, you can't recurse into it. You
+ * can only recurse into each element.
*
* @param reader the reader
* @param sub a reader to init pointing to the first child
DBusTypeReader *sub)
{
int t;
-
- /* 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);
dbus_uint32_t array_len;
int alignment;
+ _dbus_return_if_fail (!_dbus_type_reader_array_is_empty (reader));
+
sub->container_type = DBUS_TYPE_ARRAY;
/* point type_pos at the array element type */
*type_pos += 1;
}
+static void
+skip_array_values (const DBusString *value_str,
+ int *value_pos,
+ int byte_order)
+{
+ dbus_uint32_t array_len;
+ int len_pos;
+
+ len_pos = _DBUS_ALIGN_VALUE (*value_pos, 4);
+
+ _dbus_demarshal_basic_type (value_str,
+ DBUS_TYPE_UINT32,
+ &array_len,
+ byte_order,
+ &len_pos);
+
+ *value_pos = len_pos + array_len;
+}
+
/**
* 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
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.
- */
{
DBusTypeReader sub;
reader->value_pos = sub.value_pos;
}
break;
+
+ case DBUS_TYPE_ARRAY:
+ {
+ skip_array_values (reader->value_str, &reader->value_pos, reader->byte_order);
+ skip_one_complete_type (reader->type_str, &reader->type_pos);
+ }
+ break;
default:
_dbus_marshal_skip_basic_type (reader->value_str,
_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)
+ if (reader->u.array.element_type == DBUS_TYPE_STRUCT)
{
DBusTypeReader sub;
- /* Recurse into the array element */
+ /* Recurse into the struct */
_dbus_type_reader_recurse (reader, &sub);
/* Skip everything in this element */
/* Now we are at the end of this element */
reader->value_pos = sub.value_pos;
}
+ else if (reader->u.array.element_type == DBUS_TYPE_ARRAY)
+ {
+ skip_array_values (reader->value_str, &reader->value_pos, reader->byte_order);
+ }
else
{
_dbus_marshal_skip_basic_type (reader->value_str,
sub->type_pos += element_type_len;
}
- sub->u.array.len_pos = sub->value_pos;
+ sub->u.array.len_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 4);
{
dbus_uint32_t value = 0;
&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);
_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"); \
+ } \
+} 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); \
+} while (0)
+
#define SAMPLE_INT32 12345678
#define SAMPLE_INT32_ALTERNATE 53781429
static dbus_bool_t
}
static void
-check_expected_type (DBusTypeReader *reader,
- int expected)
+real_check_expected_type (DBusTypeReader *reader,
+ int expected,
+ const char *funcname,
+ int line)
{
int t;
if (t != expected)
{
- _dbus_warn ("Read type %s while expecting %s\n",
+ _dbus_warn ("Read type %s while expecting %s at %s line %d\n",
_dbus_type_to_string (t),
- _dbus_type_to_string (expected));
+ _dbus_type_to_string (expected),
+ funcname, line);
_dbus_verbose_bytes_of_string (reader->type_str, 0,
_dbus_string_get_length (reader->type_str));
}
}
+#define check_expected_type(reader, expected) real_check_expected_type (reader, expected, _DBUS_FUNCTION_NAME, __LINE__)
+
static dbus_bool_t
read_int32 (DataBlock *block,
DBusTypeReader *reader)
_dbus_assert (v == SAMPLE_INT32);
- _dbus_type_reader_next (&sub);
+ NEXT_EXPECTING_TRUE (&sub);
check_expected_type (&sub, DBUS_TYPE_INT32);
_dbus_type_reader_read_basic (&sub,
(dbus_int32_t*) &v);
_dbus_assert (v == SAMPLE_INT32_ALTERNATE);
+
+ NEXT_EXPECTING_FALSE (&sub);
return TRUE;
}
if (!read_struct_with_int32s (block, &sub))
return FALSE;
- _dbus_type_reader_next (&sub);
+
+ NEXT_EXPECTING_TRUE (&sub);
if (!read_struct_with_int32s (block, &sub))
return FALSE;
- _dbus_type_reader_next (&sub);
+
+ NEXT_EXPECTING_TRUE (&sub);
if (!read_struct_with_int32s (block, &sub))
return FALSE;
+ NEXT_EXPECTING_FALSE (&sub);
+
return TRUE;
}
if (!read_struct_of_structs (block, &sub))
return FALSE;
- _dbus_type_reader_next (&sub);
+
+ NEXT_EXPECTING_TRUE (&sub);
if (!read_struct_of_structs (block, &sub))
return FALSE;
+
+ NEXT_EXPECTING_FALSE (&sub);
return TRUE;
}
_dbus_assert (v == SAMPLE_INT32_ALTERNATE);
- _dbus_type_reader_next (&sub);
+ NEXT_EXPECTING_TRUE (&sub);
check_expected_type (&sub, DBUS_TYPE_INT32);
_dbus_type_reader_read_basic (&sub,
_dbus_assert (v == SAMPLE_INT32);
- _dbus_type_reader_next (&sub);
+ NEXT_EXPECTING_TRUE (&sub);
check_expected_type (&sub, DBUS_TYPE_INT32);
_dbus_type_reader_read_basic (&sub,
(dbus_int32_t*) &v);
_dbus_assert (v == SAMPLE_INT32);
+
+ NEXT_EXPECTING_FALSE (&sub);
return TRUE;
}
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);
+ /* We are iterating over values not types. Thus we can't recurse
+ * into the array
+ */
+ _dbus_assert (_dbus_type_reader_array_is_empty (reader));
return TRUE;
}
if (!read_array_of_int32 (block, &sub))
return FALSE;
- _dbus_type_reader_next (&sub);
+
+ NEXT_EXPECTING_TRUE (&sub);
if (!read_array_of_int32 (block, &sub))
return FALSE;
- _dbus_type_reader_next (&sub);
+
+ NEXT_EXPECTING_TRUE (&sub);
if (!read_array_of_int32_empty (block, &sub))
return FALSE;
- _dbus_type_reader_next (&sub);
+
+ NEXT_EXPECTING_TRUE (&sub);
if (!read_array_of_int32 (block, &sub))
return FALSE;
- _dbus_type_reader_next (&sub);
+
+ NEXT_EXPECTING_FALSE (&sub);
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);
+ /* We are iterating over values, not types. Thus
+ * we can't recurse in here.
+ */
+
+ _dbus_assert (_dbus_type_reader_array_is_empty (reader));
return TRUE;
}
if (!read_array_of_array_of_int32 (block, &sub))
return FALSE;
- _dbus_type_reader_next (&sub);
+
+ NEXT_EXPECTING_TRUE (&sub);
if (!read_array_of_array_of_int32 (block, &sub))
return FALSE;
- _dbus_type_reader_next (&sub);
+
+ NEXT_EXPECTING_TRUE (&sub);
if (!read_array_of_array_of_int32_empty (block, &sub))
return FALSE;
- _dbus_type_reader_next (&sub);
+
+ NEXT_EXPECTING_FALSE (&sub);
return TRUE;
}
projects / platform / upstream / dbus.git / commitdiff