X-Git-Url: http://git.efficios.com/?p=babeltrace.git;a=blobdiff_plain;f=formats%2Fctf%2Fmetadata%2Fctf-visitor-generate-io-struct.c;h=bdb5c68d6cfaa45ec3395fc7ad408eb23ff9792a;hp=9a5cda096f321509527492b24d0510dc613dda4b;hb=43f9090cab93646a1651720ecc1c52758cae7795;hpb=b4c19c1e0a905f94146e6f319218fb16b7ebbca1

diff --git a/formats/ctf/metadata/ctf-visitor-generate-io-struct.c b/formats/ctf/metadata/ctf-visitor-generate-io-struct.c
index 9a5cda09..bdb5c68d 100644
--- a/formats/ctf/metadata/ctf-visitor-generate-io-struct.c
+++ b/formats/ctf/metadata/ctf-visitor-generate-io-struct.c
@@ -325,7 +325,7 @@ struct declaration *ctf_type_declarator_visit(FILE *fd, int depth,
 					 */
 					integer_declaration = integer_declaration_new(integer_declaration->len,
 						integer_declaration->byte_order, integer_declaration->signedness,
-						integer_declaration->p.alignment, 16);
+						integer_declaration->p.alignment, 16, integer_declaration->encoding);
 					nested_declaration = &integer_declaration->p;
 				}
 			}
@@ -350,6 +350,11 @@ struct declaration *ctf_type_declarator_visit(FILE *fd, int depth,
 
 		/* TYPEDEC_NESTED */
 
+		if (!nested_declaration) {
+			fprintf(fd, "[error] %s: nested type is unknown.\n", __func__);
+			return NULL;
+		}
+
 		/* create array/sequence, pass nested_declaration as child. */
 		if (cds_list_empty(&node_type_declarator->u.type_declarator.u.nested.length)) {
 			fprintf(fd, "[error] %s: expecting length field reference or value.\n", __func__);
@@ -426,6 +431,13 @@ int ctf_struct_type_declarators_visit(FILE *fd, int depth,
 			fprintf(fd, "[error] %s: unable to find struct field declaration type\n", __func__);
 			return -EINVAL;
 		}
+
+		/* Check if field with same name already exists */
+		if (struct_declaration_lookup_field_index(struct_declaration, field_name) >= 0) {
+			fprintf(fd, "[error] %s: duplicate field %s in struct\n", __func__, g_quark_to_string(field_name));
+			return -EINVAL;
+		}
+
 		struct_declaration_add_field(struct_declaration,
 					     g_quark_to_string(field_name),
 					     field_declaration);
@@ -456,6 +468,13 @@ int ctf_variant_type_declarators_visit(FILE *fd, int depth,
 			fprintf(fd, "[error] %s: unable to find variant field declaration type\n", __func__);
 			return -EINVAL;
 		}
+
+		if (untagged_variant_declaration_get_field_from_tag(untagged_variant_declaration, field_name) != NULL) {
+			fprintf(fd, "[error] %s: duplicate field %s in variant\n", __func__, g_quark_to_string(field_name));
+			return -EINVAL;
+		}
+
+
 		untagged_variant_declaration_add_field(untagged_variant_declaration,
 					      g_quark_to_string(field_name),
 					      field_declaration);
@@ -1076,6 +1095,7 @@ struct declaration *ctf_declaration_integer_visit(FILE *fd, int depth,
 	int signedness = 0;
 	int has_alignment = 0, has_size = 0;
 	int base = 0;
+	enum ctf_string_encoding encoding = CTF_STRING_NONE;
 	struct declaration_integer *integer_declaration;
 
 	cds_list_for_each_entry(expression, expressions, siblings) {
@@ -1164,6 +1184,36 @@ struct declaration *ctf_declaration_integer_visit(FILE *fd, int depth,
 					__func__);
 				return NULL;
 			}
+		} else if (!strcmp(left->u.unary_expression.u.string, "encoding")) {
+			char *s_right;
+
+			if (right->u.unary_expression.type != UNARY_STRING) {
+				fprintf(fd, "[error] %s: encoding: expecting unary string\n",
+					__func__);
+				return NULL;
+			}
+			s_right = concatenate_unary_strings(&expression->u.ctf_expression.right);
+			if (!s_right) {
+				fprintf(fd, "[error] %s: unexpected unary expression for integer base\n", __func__);
+				g_free(s_right);
+				return NULL;
+			}
+			if (!strcmp(s_right, "UTF8")
+			    || !strcmp(s_right, "utf8")
+			    || !strcmp(s_right, "utf-8")
+			    || !strcmp(s_right, "UTF-8"))
+				encoding = CTF_STRING_UTF8;
+			else if (!strcmp(s_right, "ASCII")
+			    || !strcmp(s_right, "ascii"))
+				encoding = CTF_STRING_ASCII;
+			else if (!strcmp(s_right, "none"))
+				encoding = CTF_STRING_NONE;
+			else {
+				fprintf(fd, "[error] %s: unknown string encoding \"%s\"\n", __func__, s_right);
+				g_free(s_right);
+				return NULL;
+			}
+			g_free(s_right);
 		} else {
 			fprintf(fd, "[error] %s: unknown attribute name %s\n",
 				__func__, left->u.unary_expression.u.string);
@@ -1184,7 +1234,8 @@ struct declaration *ctf_declaration_integer_visit(FILE *fd, int depth,
 		}
 	}
 	integer_declaration = integer_declaration_new(size,
-				byte_order, signedness, alignment, base);
+				byte_order, signedness, alignment,
+				base, encoding);
 	return &integer_declaration->p;
 }
 
@@ -1519,7 +1570,6 @@ int ctf_event_visit(FILE *fd, int depth, struct ctf_node *node,
 	int ret = 0;
 	struct ctf_node *iter;
 	struct ctf_event *event;
-	struct definition_scope *parent_def_scope;
 
 	event = g_new0(struct ctf_event, 1);
 	event->declaration_scope = new_declaration_scope(parent_declaration_scope);
@@ -1564,38 +1614,9 @@ int ctf_event_visit(FILE *fd, int depth, struct ctf_node *node,
 	g_hash_table_insert(event->stream->event_quark_to_id,
 			    (gpointer)(unsigned long) event->name,
 			    &event->id);
-	parent_def_scope = event->stream->definition_scope;
-	if (event->context_decl) {
-		struct definition *definition =
-			event->context_decl->p.definition_new(&event->context_decl->p,
-				parent_def_scope, 0, 0, "event.context");
-		if (!definition) {
-			ret = -EINVAL;
-			goto error;
-		}
-		event->context = container_of(definition,
-					struct definition_struct, p);
-		parent_def_scope = event->context->scope;
-	}
-	if (event->fields_decl) {
-		struct definition *definition =
-			event->fields_decl->p.definition_new(&event->fields_decl->p,
-				parent_def_scope, 0, 0, "event.fields");
-		if (!definition) {
-			ret = -EINVAL;
-			goto error;
-		}
-		event->fields = container_of(definition,
-					struct definition_struct, p);
-		parent_def_scope = event->fields->scope;
-	}
 	return 0;
 
 error:
-	if (event->context)
-		definition_unref(&event->context->p);
-	if (event->fields)
-		definition_unref(&event->fields->p);
 	if (event->fields_decl)
 		declaration_unref(&event->fields_decl->p);
 	if (event->context_decl)
@@ -1735,13 +1756,12 @@ int ctf_stream_visit(FILE *fd, int depth, struct ctf_node *node,
 	int ret = 0;
 	struct ctf_node *iter;
 	struct ctf_stream_class *stream;
-	struct definition_scope *parent_def_scope;
 
 	stream = g_new0(struct ctf_stream_class, 1);
 	stream->declaration_scope = new_declaration_scope(parent_declaration_scope);
 	stream->events_by_id = g_ptr_array_new();
 	stream->event_quark_to_id = g_hash_table_new(g_direct_hash, g_direct_equal);
-	stream->files = g_ptr_array_new();
+	stream->streams = g_ptr_array_new();
 	if (node) {
 		cds_list_for_each_entry(iter, &node->u.stream.declaration_list, siblings) {
 			ret = ctf_stream_declaration_visit(fd, depth + 1, iter, stream, trace);
@@ -1770,61 +1790,16 @@ int ctf_stream_visit(FILE *fd, int depth, struct ctf_node *node,
 		g_ptr_array_set_size(trace->streams, stream->stream_id + 1);
 	g_ptr_array_index(trace->streams, stream->stream_id) = stream;
 
-	parent_def_scope = trace->definition_scope;
-	if (stream->packet_context_decl) {
-		struct definition *definition =
-			stream->packet_context_decl->p.definition_new(&stream->packet_context_decl->p,
-				parent_def_scope, 0, 0, "stream.packet.context");
-		if (!definition) {
-			ret = -EINVAL;
-			goto error;
-		}
-		stream->packet_context = container_of(definition,
-						struct definition_struct, p);
-		parent_def_scope = stream->packet_context->scope;
-	}
-	if (stream->event_header_decl) {
-		struct definition *definition =
-			stream->event_header_decl->p.definition_new(&stream->event_header_decl->p,
-				parent_def_scope, 0, 0, "stream.event.header");
-		if (!definition) {
-			ret = -EINVAL;
-			goto error;
-		}
-		stream->event_header =
-			container_of(definition, struct definition_struct, p);
-		parent_def_scope = stream->event_header->scope;
-	}
-	if (stream->event_context_decl) {
-		struct definition *definition =
-			stream->event_context_decl->p.definition_new(&stream->event_context_decl->p,
-				parent_def_scope, 0, 0, "stream.event.context");
-		if (!definition) {
-			ret = -EINVAL;
-			goto error;
-		}
-		stream->event_context =
-			container_of(definition, struct definition_struct, p);
-		parent_def_scope = stream->event_context->scope;
-	}
-	stream->definition_scope = parent_def_scope;
-
 	return 0;
 
 error:
-	if (stream->event_context)
-		definition_unref(&stream->event_context->p);
-	if (stream->event_header)
-		definition_unref(&stream->event_header->p);
-	if (stream->packet_context)
-		definition_unref(&stream->packet_context->p);
 	if (stream->event_header_decl)
 		declaration_unref(&stream->event_header_decl->p);
 	if (stream->event_context_decl)
 		declaration_unref(&stream->event_context_decl->p);
 	if (stream->packet_context_decl)
 		declaration_unref(&stream->packet_context_decl->p);
-	g_ptr_array_free(stream->files, TRUE);
+	g_ptr_array_free(stream->streams, TRUE);
 	g_ptr_array_free(stream->events_by_id, TRUE);
 	g_hash_table_destroy(stream->event_quark_to_id);
 	free_declaration_scope(stream->declaration_scope);
@@ -1888,7 +1863,8 @@ int ctf_trace_declaration_visit(FILE *fd, int depth, struct ctf_node *node, stru
 			CTF_TRACE_SET_FIELD(trace, minor);
 		} else if (!strcmp(left, "uuid")) {
 			uuid_t uuid;
-			ret = get_unary_uuid(&node->u.ctf_expression.right, &trace->uuid);
+
+			ret = get_unary_uuid(&node->u.ctf_expression.right, &uuid);
 			if (ret) {
 				fprintf(fd, "[error] %s: unexpected unary expression for trace uuid\n", __func__);
 				ret = -EINVAL;
@@ -1899,22 +1875,27 @@ int ctf_trace_declaration_visit(FILE *fd, int depth, struct ctf_node *node, stru
 				fprintf(fd, "[error] %s: uuid mismatch\n", __func__);
 				ret = -EPERM;
 				goto error;
+			} else {
+				memcpy(trace->uuid, uuid, sizeof(uuid));
 			}
 			CTF_TRACE_SET_FIELD(trace, uuid);
 		} else if (!strcmp(left, "byte_order")) {
 			struct ctf_node *right;
 			int byte_order;
 
-			if (CTF_TRACE_FIELD_IS_SET(trace, byte_order)) {
-				fprintf(fd, "[error] %s: endianness already declared in trace declaration\n", __func__);
-				ret = -EPERM;
-				goto error;
-			}
 			right = _cds_list_first_entry(&node->u.ctf_expression.right, struct ctf_node, siblings);
 			byte_order = get_trace_byte_order(fd, depth, right);
 			if (byte_order < 0)
 				return -EINVAL;
-			trace->byte_order = byte_order;
+
+			if (CTF_TRACE_FIELD_IS_SET(trace, byte_order)
+				&& byte_order != trace->byte_order) {
+				fprintf(fd, "[error] %s: endianness mismatch\n", __func__);
+				ret = -EPERM;
+				goto error;
+			} else {
+				trace->byte_order = byte_order;
+			}
 			CTF_TRACE_SET_FIELD(trace, byte_order);
 		} else if (!strcmp(left, "packet.header")) {
 			struct declaration *declaration;
@@ -1958,7 +1939,6 @@ error:
 static
 int ctf_trace_visit(FILE *fd, int depth, struct ctf_node *node, struct ctf_trace *trace)
 {
-	struct definition_scope *parent_def_scope;
 	int ret = 0;
 	struct ctf_node *iter;
 
@@ -1992,24 +1972,9 @@ int ctf_trace_visit(FILE *fd, int depth, struct ctf_node *node, struct ctf_trace
 		goto error;
 	}
 
-	parent_def_scope = NULL;
-	if (trace->packet_header_decl) {
-		struct definition *definition =
-			trace->packet_header_decl->p.definition_new(&trace->packet_header_decl->p,
-				parent_def_scope, 0, 0, "trace.packet.header");
-		if (!definition) {
-			ret = -EINVAL;
-			goto error;
-		}
-		trace->packet_header =
-			container_of(definition, struct definition_struct, p);
-		parent_def_scope = trace->packet_header->scope;
-	}
-	trace->definition_scope = parent_def_scope;
-
 	if (!CTF_TRACE_FIELD_IS_SET(trace, byte_order)) {
 		/* check that the packet header contains a "magic" field */
-		if (!trace->packet_header
+		if (!trace->packet_header_decl
 		    || struct_declaration_lookup_field_index(trace->packet_header_decl, g_quark_from_static_string("magic")) < 0) {
 			ret = -EPERM;
 			fprintf(fd, "[error] %s: missing both byte_order and packet header magic number in trace declaration\n", __func__);
@@ -2019,8 +1984,6 @@ int ctf_trace_visit(FILE *fd, int depth, struct ctf_node *node, struct ctf_trace
 	return 0;
 
 error:
-	if (trace->packet_header)
-		definition_unref(&trace->packet_header->p);
 	if (trace->packet_header_decl)
 		declaration_unref(&trace->packet_header_decl->p);
 	g_ptr_array_free(trace->streams, TRUE);
@@ -2081,7 +2044,6 @@ int ctf_visitor_construct_metadata(FILE *fd, int depth, struct ctf_node *node,
 
 	printf_verbose("CTF visitor: metadata construction... ");
 	trace->root_declaration_scope = new_declaration_scope(NULL);
-	trace->streams = g_ptr_array_new();
 	trace->byte_order = byte_order;
 
 	switch (node->type) {
@@ -2091,26 +2053,27 @@ int ctf_visitor_construct_metadata(FILE *fd, int depth, struct ctf_node *node,
 			ret = ctf_root_declaration_visit(fd, depth + 1, iter, trace);
 			if (ret) {
 				fprintf(fd, "[error] %s: root declaration error\n", __func__);
-				return ret;
+				goto error;
 			}
 		}
 		cds_list_for_each_entry(iter, &node->u.root.trace, siblings) {
 			ret = ctf_trace_visit(fd, depth + 1, iter, trace);
 			if (ret) {
 				fprintf(fd, "[error] %s: trace declaration error\n", __func__);
-				return ret;
+				goto error;
 			}
 		}
 		if (!trace->streams) {
 			fprintf(fd, "[error] %s: missing trace declaration\n", __func__);
-			return -EINVAL;
+			ret = -EINVAL;
+			goto error;
 		}
 		cds_list_for_each_entry(iter, &node->u.root.stream, siblings) {
 			ret = ctf_stream_visit(fd, depth + 1, iter,
 		    			       trace->root_declaration_scope, trace);
 			if (ret) {
 				fprintf(fd, "[error] %s: stream declaration error\n", __func__);
-				return ret;
+				goto error;
 			}
 		}
 		cds_list_for_each_entry(iter, &node->u.root.event, siblings) {
@@ -2118,7 +2081,7 @@ int ctf_visitor_construct_metadata(FILE *fd, int depth, struct ctf_node *node,
 		    			      trace->root_declaration_scope, trace);
 			if (ret) {
 				fprintf(fd, "[error] %s: event declaration error\n", __func__);
-				return ret;
+				goto error;
 			}
 		}
 		break;
@@ -2126,8 +2089,13 @@ int ctf_visitor_construct_metadata(FILE *fd, int depth, struct ctf_node *node,
 	default:
 		fprintf(fd, "[error] %s: unknown node type %d\n", __func__,
 			(int) node->type);
-		return -EINVAL;
+		ret = -EINVAL;
+		goto error;
 	}
 	printf_verbose("done.\n");
 	return ret;
+
+error:
+	free_declaration_scope(trace->root_declaration_scope);
+	return ret;
 }