struct DBusTypeReaderClass
{
const char *name;
+ int id; /* index in all_reader_classes */
dbus_bool_t types_only; /* only iterates over types, not values */
- void (* recurse) (DBusTypeReader *sub,
- DBusTypeReader *parent);
- int (* get_current_type) (DBusTypeReader *reader);
- void (* next) (DBusTypeReader *reader,
- int current_type);
+ void (* recurse) (DBusTypeReader *sub,
+ DBusTypeReader *parent);
+ int (* get_current_type) (DBusTypeReader *reader);
+ void (* next) (DBusTypeReader *reader,
+ int current_type);
+ void (* init_from_mark) (DBusTypeReader *reader,
+ const DBusTypeMark *mark);
};
static int
/* point type_pos at the array element type */
sub->type_pos += 1;
- sub->u.array.element_type = first_type_in_signature (sub->type_str,
- sub->type_pos);
-
/* Init with values likely to crash things if misused */
sub->u.array.start_pos = _DBUS_INT_MAX;
- sub->u.array.len = _DBUS_INT_MAX;
+ sub->array_len_offset = 7;
+}
+
+static int
+array_reader_get_array_len (DBusTypeReader *reader)
+{
+ dbus_uint32_t array_len;
+ int len_pos;
+
+ /* array_len_offset is the offset back from start_pos to end of the len */
+ len_pos = reader->u.array.start_pos - ((int)reader->array_len_offset) - 4;
+
+ _dbus_demarshal_basic_type (reader->value_str,
+ DBUS_TYPE_UINT32,
+ &array_len,
+ reader->byte_order,
+ len_pos, NULL);
+
+ _dbus_verbose (" reader %p len_pos %d array len %u len_offset %d\n",
+ reader, len_pos, array_len, reader->array_len_offset);
+
+ _dbus_assert (reader->u.array.start_pos - len_pos - 4 < 8);
+
+ return array_len;
}
static void
array_reader_recurse (DBusTypeReader *sub,
DBusTypeReader *parent)
{
- dbus_uint32_t array_len;
int alignment;
+ int len_pos;
_dbus_assert (!_dbus_type_reader_array_is_empty (parent));
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->value_pos);
-
- sub->u.array.len = array_len;
+ len_pos = sub->value_pos;
+ sub->value_pos += 4; /* for the length */
+
alignment = element_type_get_alignment (sub->type_str,
sub->type_pos);
sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, alignment);
sub->u.array.start_pos = sub->value_pos;
+ _dbus_assert ((sub->u.array.start_pos - (len_pos + 4)) < 8); /* only 3 bits in array_len_offset */
+ sub->array_len_offset = sub->u.array.start_pos - (len_pos + 4);
#if RECURSIVE_MARSHAL_TRACE
- _dbus_verbose (" type reader %p array start = %d array len = %d array element type = %s\n",
+ _dbus_verbose (" type reader %p array start = %d len_offset = %d array len = %d array element type = %s\n",
sub,
sub->u.array.start_pos,
- sub->u.array.len,
- _dbus_type_to_string (sub->u.array.element_type));
+ sub->array_len_offset,
+ array_reader_get_array_len (sub),
+ _dbus_type_to_string (first_type_in_signature (sub->type_str,
+ sub->type_pos)));
#endif
}
if (reader->finished)
t = DBUS_TYPE_INVALID;
else
- t = reader->u.array.element_type;
+ t = first_type_in_signature (reader->type_str,
+ reader->type_pos);
return t;
}
* TYPE_INVALID otherwise
*/
- end_pos = reader->u.array.start_pos + reader->u.array.len;
+ end_pos = reader->u.array.start_pos + array_reader_get_array_len (reader);
_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;
+ t = first_type_in_signature (reader->type_str,
+ reader->type_pos);
else
t = DBUS_TYPE_INVALID;
/* Skip one array element */
int end_pos;
- end_pos = reader->u.array.start_pos + reader->u.array.len;
+ end_pos = reader->u.array.start_pos + array_reader_get_array_len (reader);
_dbus_assert (reader->value_pos < end_pos);
_dbus_assert (reader->value_pos >= reader->u.array.start_pos);
- switch (reader->u.array.element_type)
+ switch (first_type_in_signature (reader->type_str,
+ reader->type_pos))
{
case DBUS_TYPE_STRUCT:
case DBUS_TYPE_VARIANT:
}
}
+static void
+array_init_from_mark (DBusTypeReader *reader,
+ const DBusTypeMark *mark)
+{
+ /* Fill in the array-specific fields from the mark. The general
+ * fields are already filled in.
+ */
+ reader->u.array.start_pos = mark->array_start_pos;
+ reader->array_len_offset = mark->array_len_offset;
+}
+
static const DBusTypeReaderClass body_reader_class = {
- "body",
+ "body", 0,
FALSE,
NULL, /* body is always toplevel, so doesn't get recursed into */
base_reader_get_current_type,
- base_reader_next
+ base_reader_next,
+ NULL
};
static const DBusTypeReaderClass body_types_only_reader_class = {
- "body types",
+ "body types", 1,
TRUE,
NULL, /* body is always toplevel, so doesn't get recursed into */
base_reader_get_current_type,
- base_reader_next
+ base_reader_next,
+ NULL
};
static const DBusTypeReaderClass struct_reader_class = {
- "struct",
+ "struct", 2,
FALSE,
struct_reader_recurse,
struct_reader_get_current_type,
- struct_reader_next
+ struct_reader_next,
+ NULL
};
static const DBusTypeReaderClass struct_types_only_reader_class = {
- "struct types",
+ "struct types", 3,
TRUE,
struct_types_only_reader_recurse,
struct_reader_get_current_type,
- struct_reader_next
+ struct_reader_next,
+ NULL
};
static const DBusTypeReaderClass array_reader_class = {
- "array",
+ "array", 4,
FALSE,
array_reader_recurse,
array_reader_get_current_type,
- array_reader_next
+ array_reader_next,
+ array_init_from_mark
};
static const DBusTypeReaderClass array_types_only_reader_class = {
- "array types",
+ "array types", 5,
TRUE,
array_types_only_reader_recurse,
array_types_only_reader_get_current_type,
- array_types_only_reader_next
+ array_types_only_reader_next,
+ NULL
};
static const DBusTypeReaderClass variant_reader_class = {
- "variant",
+ "variant", 6,
FALSE,
variant_reader_recurse,
base_reader_get_current_type,
- base_reader_next
+ base_reader_next,
+ NULL
+};
+
+static const DBusTypeReaderClass const *
+all_reader_classes[] = {
+ &body_reader_class,
+ &body_types_only_reader_class,
+ &struct_reader_class,
+ &struct_types_only_reader_class,
+ &array_reader_class,
+ &array_types_only_reader_class,
+ &variant_reader_class
};
void
}
void
+_dbus_type_reader_init_from_mark (DBusTypeReader *reader,
+ int byte_order,
+ const DBusString *type_str,
+ const DBusString *value_str,
+ const DBusTypeMark *mark)
+{
+ reader->klass = all_reader_classes[mark->container_type];
+
+ reader_init (reader, byte_order,
+ mark->type_pos_in_value_str ? value_str : type_str,
+ mark->type_pos,
+ value_str, mark->value_pos);
+
+ if (reader->klass->init_from_mark)
+ (* reader->klass->init_from_mark) (reader, mark);
+
+#if RECURSIVE_MARSHAL_TRACE
+ _dbus_verbose (" type reader %p init from mark 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));
+#endif
+}
+
+void
_dbus_type_reader_init_types_only (DBusTypeReader *reader,
const DBusString *type_str,
int type_pos)
#endif
}
+void
+_dbus_type_reader_init_types_only_from_mark (DBusTypeReader *reader,
+ const DBusString *type_str,
+ const DBusTypeMark *mark)
+{
+ reader->klass = all_reader_classes[mark->container_type];
+ _dbus_assert (reader->klass->types_only);
+ _dbus_assert (!mark->type_pos_in_value_str);
+
+ reader_init (reader, DBUS_COMPILER_BYTE_ORDER, /* irrelevant */
+ type_str, mark->type_pos,
+ NULL, _DBUS_INT_MAX /* crashes if we screw up */);
+
+ if (reader->klass->init_from_mark)
+ (* reader->klass->init_from_mark) (reader, mark);
+
+#if RECURSIVE_MARSHAL_TRACE
+ _dbus_verbose (" type reader %p init types only from mark type_pos = %d remaining sig '%s'\n",
+ reader, reader->type_pos,
+ _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0));
+#endif
+}
+
+void
+_dbus_type_reader_save_mark (DBusTypeReader *reader,
+ DBusTypeMark *mark)
+{
+ mark->type_pos_in_value_str = (reader->type_str == reader->value_str);
+ mark->container_type = reader->klass->id;
+ _dbus_assert (all_reader_classes[reader->klass->id] == reader->klass);
+
+ mark->type_pos = reader->type_pos;
+ mark->value_pos = reader->value_pos;
+
+ /* these are just junk if the reader isn't really an array of course */
+ mark->array_len_offset = reader->array_len_offset;
+ mark->array_start_pos = reader->u.array.start_pos;
+}
+
int
_dbus_type_reader_get_current_type (DBusTypeReader *reader)
{
_dbus_assert (!reader->klass->types_only);
/* reader is supposed to be at an array child */
- _dbus_verbose ("checking array len at %d\n", reader->value_pos);
+#if RECURSIVE_MARSHAL_TRACE
+ _dbus_verbose ("checking array len at %d\n", reader->value_pos);
+#endif
_dbus_demarshal_basic_type (reader->value_str,
DBUS_TYPE_UINT32,
reader->byte_order,
reader->value_pos,
NULL);
+#if RECURSIVE_MARSHAL_TRACE
_dbus_verbose (" ... array len = %d\n", array_len);
+#endif
return array_len == 0;
}
_dbus_assert_not_reached ("don't yet handle recursing into this type");
}
+ _dbus_assert (sub->klass == all_reader_classes[sub->klass->id]);
+
(* sub->klass->recurse) (sub, reader);
#if RECURSIVE_MARSHAL_TRACE
DBusTypeReader *reader,
int seed)
{
- return (* node->klass->read_value) (node, block, reader, seed);
+ DBusTypeMark mark;
+ DBusTypeReader restored;
+
+ _dbus_type_reader_save_mark (reader, &mark);
+
+ if (!(* node->klass->read_value) (node, block, reader, seed))
+ return FALSE;
+
+ _dbus_type_reader_init_from_mark (&restored,
+ reader->byte_order, /* a bit of a cheat,
+ * since we didn't bother
+ * to store this in DataBlock
+ */
+ &block->signature,
+ &block->body,
+ &mark);
+
+ if (!(* node->klass->read_value) (node, block, &restored, seed))
+ return FALSE;
+
+ return TRUE;
}
static dbus_bool_t
node_destroy (outer_container);
}
+#if 0
+ /* This one takes a really long time, so comment it out for now */
_dbus_verbose (">>> >>> Each container of each container of each container of each value %d iterations\n",
N_CONTAINERS * N_CONTAINERS * N_CONTAINERS * N_VALUES);
for (i = 0; i < N_CONTAINERS; i++)
}
node_destroy (outer_container);
}
+#endif /* #if 0 expensive test */
_dbus_verbose (">>> >>> Each value,value,value triplet combination as toplevel, in all orders %d iterations\n",
N_VALUES * N_VALUES * N_VALUES);
#define DBUS_MARSHAL_RECURSIVE_H
#include <config.h>
-#include <dbus/dbus-marshal-basic.h> /* this can become protocol.h when we merge */
+#include <dbus/dbus-protocol.h>
+#include <dbus/dbus-marshal-basic.h> /* this can vanish when we merge */
#ifndef PACKAGE
#error "config.h not included here"
* - delete an array element and re-align the remainder of the array
* (not necessary yet to re-align remainder of entire string,
* though that's probably just as hard/easy)
+ * (really this one is to set a complex-type array element to
+ * a new value, but for dbus-message.c delete-and-reappend would
+ * be good enough)
* - set string, int, etc. values at a memoized position
* (implement generic set of any value? changes only
* value_str not type_str)
* - validation
*/
+typedef struct DBusTypeMark DBusTypeMark;
typedef struct DBusTypeReader DBusTypeReader;
typedef struct DBusTypeWriter DBusTypeWriter;
typedef struct DBusTypeReaderClass DBusTypeReaderClass;
+/* The mark is a way to compress a TypeReader; it isn't all that
+ * successful though.
+ */
+struct DBusTypeMark
+{
+ dbus_uint32_t type_pos_in_value_str : 1;
+ dbus_uint32_t container_type : 3;
+ dbus_uint32_t array_len_offset : 3; /* bytes back from start_pos that len ends */
+ dbus_uint32_t type_pos : DBUS_MAXIMUM_MESSAGE_LENGTH_BITS;
+ dbus_uint32_t value_pos : DBUS_MAXIMUM_MESSAGE_LENGTH_BITS;
+ dbus_uint32_t array_start_pos : DBUS_MAXIMUM_MESSAGE_LENGTH_BITS;
+};
+
struct DBusTypeReader
{
dbus_uint32_t byte_order : 8;
dbus_uint32_t finished : 1; /* marks we're at end iterator for cases
* where we don't have another way to tell
*/
+ dbus_uint32_t array_len_offset : 3; /* bytes back from start_pos that len ends */
const DBusString *type_str;
int type_pos;
const DBusString *value_str;
{
struct {
int start_pos;
- dbus_uint32_t len;
- int element_type;
} array;
} u;
};
} u;
};
-void _dbus_type_reader_init (DBusTypeReader *reader,
- int byte_order,
- const DBusString *type_str,
- int type_pos,
- const DBusString *value_str,
- int value_pos);
-void _dbus_type_reader_init_types_only (DBusTypeReader *reader,
- const DBusString *type_str,
- int type_pos);
-int _dbus_type_reader_get_current_type (DBusTypeReader *reader);
-dbus_bool_t _dbus_type_reader_array_is_empty (DBusTypeReader *reader);
-void _dbus_type_reader_read_basic (DBusTypeReader *reader,
- void *value);
-dbus_bool_t _dbus_type_reader_read_array_of_basic (DBusTypeReader *reader,
- int type,
- void **array,
- int *array_len);
-void _dbus_type_reader_recurse (DBusTypeReader *reader,
- DBusTypeReader *subreader);
-dbus_bool_t _dbus_type_reader_next (DBusTypeReader *reader);
+void _dbus_type_reader_init (DBusTypeReader *reader,
+ int byte_order,
+ const DBusString *type_str,
+ int type_pos,
+ const DBusString *value_str,
+ int value_pos);
+void _dbus_type_reader_init_from_mark (DBusTypeReader *reader,
+ int byte_order,
+ const DBusString *type_str,
+ const DBusString *value_str,
+ const DBusTypeMark *mark);
+void _dbus_type_reader_init_types_only (DBusTypeReader *reader,
+ const DBusString *type_str,
+ int type_pos);
+void _dbus_type_reader_init_types_only_from_mark (DBusTypeReader *reader,
+ const DBusString *type_str,
+ const DBusTypeMark *mark);
+void _dbus_type_reader_save_mark (DBusTypeReader *reader,
+ DBusTypeMark *mark);
+int _dbus_type_reader_get_current_type (DBusTypeReader *reader);
+dbus_bool_t _dbus_type_reader_array_is_empty (DBusTypeReader *reader);
+void _dbus_type_reader_read_basic (DBusTypeReader *reader,
+ void *value);
+dbus_bool_t _dbus_type_reader_read_array_of_basic (DBusTypeReader *reader,
+ int type,
+ void **array,
+ int *array_len);
+void _dbus_type_reader_recurse (DBusTypeReader *reader,
+ DBusTypeReader *subreader);
+dbus_bool_t _dbus_type_reader_next (DBusTypeReader *reader);
+
void _dbus_type_writer_init (DBusTypeWriter *writer,
int byte_order,
projects / platform / upstream / dbus.git / commitdiff