X-Git-Url: http://git.efficios.com/?p=babeltrace.git;a=blobdiff_plain;f=types%2Fsequence.c;h=8db1ee0466b66b2bb7d661bb6245e4f2db3f9f3f;hp=d455dff337e7469ecb1fdf7ddfb0b7f35d78e82e;hb=f66259163f060ada8d0fee348857c968e338ea40;hpb=e1151715912eaec959682b3bc10be3ced6abe467

diff --git a/types/sequence.c b/types/sequence.c
index d455dff3..8db1ee04 100644
--- a/types/sequence.c
+++ b/types/sequence.c
@@ -24,7 +24,7 @@
 #endif
 
 static
-struct definition *_sequence_definition_new(struct type *type,
+struct definition *_sequence_definition_new(struct declaration *declaration,
 					struct definition_scope *parent_scope);
 static
 void _sequence_definition_free(struct definition *definition);
@@ -35,84 +35,84 @@ void sequence_copy(struct stream_pos *dest, const struct format *fdest,
 {
 	struct definition_sequence *sequence =
 		container_of(definition, struct definition_sequence, p);
-	struct type_sequence *sequence_type = sequence->type;
+	struct declaration_sequence *sequence_declaration = sequence->declaration;
 	uint64_t i;
 
-	fsrc->sequence_begin(src, sequence_type);
-	fdest->sequence_begin(dest, sequence_type);
+	fsrc->sequence_begin(src, sequence_declaration);
+	fdest->sequence_begin(dest, sequence_declaration);
 
-	sequence->len->p.type->copy(dest, fdest, src, fsrc,
+	sequence->len->p.declaration->copy(dest, fdest, src, fsrc,
 				    &sequence->len->p);
 
 	for (i = 0; i < sequence->len->value._unsigned; i++) {
 		struct definition *elem =
 			sequence->current_element.definition;
-		elem->type->copy(dest, fdest, src, fsrc, elem);
+		elem->declaration->copy(dest, fdest, src, fsrc, elem);
 	}
-	fsrc->sequence_end(src, sequence_type);
-	fdest->sequence_end(dest, sequence_type);
+	fsrc->sequence_end(src, sequence_declaration);
+	fdest->sequence_end(dest, sequence_declaration);
 }
 
 static
-void _sequence_type_free(struct type *type)
+void _sequence_declaration_free(struct declaration *declaration)
 {
-	struct type_sequence *sequence_type =
-		container_of(type, struct type_sequence, p);
+	struct declaration_sequence *sequence_declaration =
+		container_of(declaration, struct declaration_sequence, p);
 
-	free_type_scope(sequence_type->scope);
-	type_unref(&sequence_type->len_type->p);
-	type_unref(sequence_type->elem);
-	g_free(sequence_type);
+	free_declaration_scope(sequence_declaration->scope);
+	declaration_unref(&sequence_declaration->len_declaration->p);
+	declaration_unref(sequence_declaration->elem);
+	g_free(sequence_declaration);
 }
 
-struct type_sequence *
-	sequence_type_new(const char *name, struct type_integer *len_type,
-			  struct type *elem_type,
-			  struct type_scope *parent_scope)
+struct declaration_sequence *
+	sequence_declaration_new(const char *name, struct declaration_integer *len_declaration,
+			  struct declaration *elem_declaration,
+			  struct declaration_scope *parent_scope)
 {
-	struct type_sequence *sequence_type;
-	struct type *type;
+	struct declaration_sequence *sequence_declaration;
+	struct declaration *declaration;
 
-	sequence_type = g_new(struct type_sequence, 1);
-	type = &sequence_type->p;
-	assert(!len_type->signedness);
-	type_ref(&len_type->p);
-	sequence_type->len_type = len_type;
-	type_ref(elem_type);
-	sequence_type->elem = elem_type;
-	sequence_type->scope = new_type_scope(parent_scope);
-	type->id = CTF_TYPE_SEQUENCE;
-	type->name = g_quark_from_string(name);
-	type->alignment = max(len_type->p.alignment, elem_type->alignment);
-	type->copy = sequence_copy;
-	type->type_free = _sequence_type_free;
-	type->definition_new = _sequence_definition_new;
-	type->definition_free = _sequence_definition_free;
-	type->ref = 1;
-	return sequence_type;
+	sequence_declaration = g_new(struct declaration_sequence, 1);
+	declaration = &sequence_declaration->p;
+	assert(!len_declaration->signedness);
+	declaration_ref(&len_declaration->p);
+	sequence_declaration->len_declaration = len_declaration;
+	declaration_ref(elem_declaration);
+	sequence_declaration->elem = elem_declaration;
+	sequence_declaration->scope = new_declaration_scope(parent_scope);
+	declaration->id = CTF_TYPE_SEQUENCE;
+	declaration->name = g_quark_from_string(name);
+	declaration->alignment = max(len_declaration->p.alignment, elem_declaration->alignment);
+	declaration->copy = sequence_copy;
+	declaration->declaration_free = _sequence_declaration_free;
+	declaration->definition_new = _sequence_definition_new;
+	declaration->definition_free = _sequence_definition_free;
+	declaration->ref = 1;
+	return sequence_declaration;
 }
 
 static
-struct definition *_sequence_definition_new(struct type *type,
+struct definition *_sequence_definition_new(struct declaration *declaration,
 				struct definition_scope *parent_scope)
 {
-	struct type_sequence *sequence_type =
-		container_of(type, struct type_sequence, p);
+	struct declaration_sequence *sequence_declaration =
+		container_of(declaration, struct declaration_sequence, p);
 	struct definition_sequence *sequence;
 	struct definition *len_parent;
 
 	sequence = g_new(struct definition_sequence, 1);
-	type_ref(&sequence_type->p);
-	sequence->p.type = type;
-	sequence->type = sequence_type;
+	declaration_ref(&sequence_declaration->p);
+	sequence->p.declaration = declaration;
+	sequence->declaration = sequence_declaration;
 	sequence->p.ref = 1;
 	sequence->scope = new_definition_scope(parent_scope);
-	len_parent = sequence_type->len_type->p.definition_new(&sequence_type->len_type->p,
+	len_parent = sequence_declaration->len_declaration->p.definition_new(&sequence_declaration->len_declaration->p,
 								parent_scope);
 	sequence->len =
 		container_of(len_parent, struct definition_integer, p);
 	sequence->current_element.definition =
-		sequence_type->elem->definition_new(sequence_type->elem,
+		sequence_declaration->elem->definition_new(sequence_declaration->elem,
 						     parent_scope);
 	return &sequence->p;
 }
@@ -126,9 +126,9 @@ void _sequence_definition_free(struct definition *definition)
 	struct definition *elem_definition =
 		sequence->current_element.definition;
 
-	len_definition->type->definition_free(len_definition);
-	elem_definition->type->definition_free(elem_definition);
+	len_definition->declaration->definition_free(len_definition);
+	elem_definition->declaration->definition_free(elem_definition);
 	free_definition_scope(sequence->scope);
-	type_unref(sequence->p.type);
+	declaration_unref(sequence->p.declaration);
 	g_free(sequence);
 }