- struct type_sequence *sequence =
- container_of(type, struct type_sequence, p);
- struct type_class_sequence *sequence_class = sequence->_class;
- uint64_t i;
-
- fsrc->sequence_begin(src, sequence);
- fdest->sequence_begin(dest, sequence);
-
- sequence->len->p._class->copy(dest, fdest, src, fsrc,
- &sequence->len->p);
-
- for (i = 0; i < sequence->len->value._unsigned; i++) {
- struct type *elem_type = sequence->current_element.type;
- elem_type->p._class->copy(dest, fdest, src, fsrc, elem_type);
+ struct definition_sequence *sequence_definition =
+ container_of(definition, struct definition_sequence, p);
+ const struct declaration_sequence *sequence_declaration =
+ sequence_definition->declaration;
+ uint64_t len, oldlen, i;
+
+ generic_rw(pos, &sequence_definition->len->p);
+ len = sequence_definition->len->value._unsigned;
+ /*
+ * Yes, large sequences could be _painfully slow_ to parse due
+ * to memory allocation for each event read. At least, never
+ * shrink the sequence. Note: the sequence GArray len should
+ * never be used as indicator of the current sequence length.
+ * One should always look at the sequence->len->value._unsigned
+ * value for that.
+ */
+ oldlen = sequence_definition->elems->len;
+ if (oldlen < len)
+ g_array_set_size(sequence_definition->elems, len);
+
+ for (i = oldlen; i < len; i++) {
+ struct field *field;
+ GString *str;
+ GQuark name;
+
+ str = g_string_new("");
+ g_string_printf(str, "[%" PRIu64 "]", i);
+ (void) g_string_free(str, TRUE);
+ name = g_quark_from_string(str->str);
+
+ field = &g_array_index(sequence_definition->elems, struct field, i);
+ field->name = name;
+ field->definition = sequence_declaration->elem->definition_new(sequence_declaration->elem,
+ sequence_definition->scope,
+ name, i);
+ generic_rw(pos, field->definition);