diff --git a/src/OVAL/oval_affected.c b/src/OVAL/oval_affected.c
index f650a84..91b3d33 100644
--- a/src/OVAL/oval_affected.c
+++ b/src/OVAL/oval_affected.c
@@ -137,6 +137,26 @@ oval_affected_family_enum _odafamily(char *family)
 	return (valstar == NULL) ? CLASS_UNKNOWN : valstar->value;
 }
 
+
+void _oval_affected_consumer(char *text, void *user) {
+	char **platform = (char **) user;
+
+	if (*platform == NULL)
+		*platform = text;
+	else {
+		int size = strlen(*platform) + strlen(text) + 1;
+		char *newtext =
+		    (char *)malloc(size * sizeof(char *));
+		*newtext = 0;
+		strcat(newtext, *platform);
+		strcat(newtext, text);
+		free(*platform);
+		free(text);
+		*platform = newtext;
+	}
+}
+
+
 int _oval_affected_parse_tag(xmlTextReaderPtr reader,
 			     struct oval_parser_context *context, void *user)
 {
@@ -146,46 +166,16 @@ int _oval_affected_parse_tag(xmlTextReaderPtr reader,
 	xmlChar *namespace = xmlTextReaderNamespaceUri(reader);
 	if (strcmp(tagname, "platform") == 0) {
 		char *platform = NULL;
-		void consumer(char *text, void *user) {
-			if (platform == NULL)
-				platform = text;
-			else {
-				int size = strlen(platform) + strlen(text) + 1;
-				char *newtext =
-				    (char *)malloc(size * sizeof(char *));
-				*newtext = 0;
-				strcat(newtext, platform);
-				strcat(newtext, text);
-				free(platform);
-				free(text);
-				platform = newtext;
-			}
-		}
 		return_code =
-		    oval_parser_text_value(reader, context, &consumer,
-					   affected);
+		    oval_parser_text_value(reader, context, &_oval_affected_consumer,
+					   (void*) &platform);
 		if (platform != NULL)
 			add_oval_affected_platform(affected, platform);
 	} else if (strcmp(tagname, "product") == 0) {
 		char *product = NULL;
-		void consumer(char *text, void *user) {
-			if (product == NULL)
-				product = text;
-			else {
-				int size = strlen(product) + strlen(text) + 1;
-				char *newtext =
-				    (char *)malloc(size * sizeof(char *));
-				*newtext = 0;
-				strcat(newtext, product);
-				strcat(newtext, text);
-				free(text);
-				free(product);
-				product = newtext;
-			}
-		}
 		return_code =
-		    oval_parser_text_value(reader, context, &consumer,
-					   affected);
+		    oval_parser_text_value(reader, context, &_oval_affected_consumer,
+					   (void*) &product);
 		if (product != NULL)
 			add_oval_affected_product(affected, product);
 	} else {
diff --git a/src/OVAL/oval_behavior.c b/src/OVAL/oval_behavior.c
index cdea407..1e28b86 100644
--- a/src/OVAL/oval_behavior.c
+++ b/src/OVAL/oval_behavior.c
@@ -83,7 +83,7 @@ struct oval_behavior *oval_behavior_new()
 void oval_behavior_free(struct oval_behavior *behavior)
 {
 	void free_value(void *value) {
-		oval_value_free(behavior->value);
+		oval_value_free(value);
 	}
 	if (behavior->value != NULL)
 		free_value((void *)behavior->value);
diff --git a/src/OVAL/oval_component.c b/src/OVAL/oval_component.c
index 2654fa7..1d33c10 100644
--- a/src/OVAL/oval_component.c
+++ b/src/OVAL/oval_component.c
@@ -484,14 +484,17 @@ void set_oval_component_variable(struct oval_component *component,
 	}
 }
 
+void _oval_component_value_consumer(struct oval_value *value, void *user) {
+	struct oval_component *component = (struct oval_component *) user;
+
+	set_oval_component_literal_value(component, value);
+}
+
 int _oval_component_parse_LITERAL_tag
     (xmlTextReaderPtr reader, struct oval_parser_context *context,
      struct oval_component *component) {
-	void value_consumer(struct oval_value *value, void *null) {
-		set_oval_component_literal_value(component, value);
-	}
 	int return_code =
-	    oval_value_parse_tag(reader, context, value_consumer, NULL);
+	    oval_value_parse_tag(reader, context, _oval_component_value_consumer, component);
 	return return_code;
 }
 
@@ -522,23 +525,30 @@ int _oval_component_parse_VARREF_tag
 	return return_code;
 }
 
+void _oval_component_subcomp_consumer(struct oval_component *subcomp, void *user) {
+	oval_component_FUNCTION_t *function = 
+	    (oval_component_FUNCTION_t *) user;
+
+	oval_collection_add(function->function_components, (void *)subcomp);
+}
+
+int _oval_component_subcomp_tag_consumer(xmlTextReaderPtr reader,
+			 struct oval_parser_context *context,
+			 void *user) {
+	return oval_component_parse_tag(reader, context,
+					&_oval_component_subcomp_consumer, user);
+}
+
 int _oval_component_parse_FUNCTION_tag
     (xmlTextReaderPtr reader, struct oval_parser_context *context,
      struct oval_component *component) {
 	oval_component_FUNCTION_t *function =
 	    (oval_component_FUNCTION_t *) component;
-	void subcomp_consumer(struct oval_component *subcomp, void *null) {
-		oval_collection_add(function->function_components,
-				    (void *)subcomp);
-	}
-	int subcomp_tag_consumer(xmlTextReaderPtr reader,
-				 struct oval_parser_context *context,
-				 void *null) {
-		return oval_component_parse_tag(reader, context,
-						&subcomp_consumer, NULL);
-	}
+
 	int return_code =
-	    oval_parser_parse_tag(reader, context, &subcomp_tag_consumer, NULL);
+	    oval_parser_parse_tag(reader, context, 
+				  &_oval_component_subcomp_tag_consumer, 
+				  function);
 	return return_code;
 }
 
diff --git a/src/OVAL/oval_criteriaNode.c b/src/OVAL/oval_criteriaNode.c
index 2437d44..190e1e6 100644
--- a/src/OVAL/oval_criteriaNode.c
+++ b/src/OVAL/oval_criteriaNode.c
@@ -169,7 +169,7 @@ void oval_criteria_node_free(struct oval_criteria_node *node)
 			struct oval_collection *subnodes =
 			    ((struct oval_criteria_node_CRITERIA *)node)->
 			    subnodes;
-			void free_node(void *null) {
+			void free_node(void *node) {
 				oval_criteria_node_free(node);
 			}
 			oval_collection_free_items(subnodes, &free_node);
@@ -240,18 +240,19 @@ void set_oval_criteria_node_definition(struct oval_criteria_node *node,
 	extenddef->definition = definition;
 }
 
+void consumer(struct oval_criteria_node *subnode, void *user) {
+	struct oval_criteria_node_CRITERIA *criteria = 
+            (struct oval_criteria_node_CRITERIA *)user;
+
+	add_oval_criteria_node_subnodes((struct oval_criteria_node *)
+					criteria, subnode);
+}
 int _oval_criteria_subnode_consumer(xmlTextReaderPtr reader,
 				    struct oval_parser_context *context,
 				    void *user)
 {
-	struct oval_criteria_node_CRITERIA *criteria =
-	    (struct oval_criteria_node_CRITERIA *)user;
-	void consumer(struct oval_criteria_node *subnode, void *null) {
-		add_oval_criteria_node_subnodes((struct oval_criteria_node *)
-						criteria, subnode);
-	}
 	int return_code =
-	    oval_criteria_parse_tag(reader, context, &consumer, NULL);
+	    oval_criteria_parse_tag(reader, context, &consumer, user);
 	return return_code;
 }
 
diff --git a/src/OVAL/oval_definition.c b/src/OVAL/oval_definition.c
index eaab8e5..3f27837 100644
--- a/src/OVAL/oval_definition.c
+++ b/src/OVAL/oval_definition.c
@@ -271,6 +271,12 @@ void _oval_definition_affected_consumer(struct oval_affected *affected,
 	oval_collection_add(definition->affected, (void *)affected);
 }
 
+void _oval_definition_reference_consumer(struct oval_reference *reference, void *user) 
+{
+	struct oval_definition *definition = (struct oval_definition *)user;
+	oval_collection_add(definition->reference, (void *)reference);
+}
+
 int _oval_definition_parse_metadata(xmlTextReaderPtr reader,
 				    struct oval_parser_context *context,
 				    void *user)
@@ -296,14 +302,10 @@ int _oval_definition_parse_metadata(xmlTextReaderPtr reader,
 	} else if (strcmp(tagname, "oval_repository") == 0) {	//NOOP
 		return_code = oval_parser_skip_tag(reader, context);
 	} else if (strcmp(tagname, "reference") == 0) {
-		void reference_consumer(struct oval_reference *reference,
-					void *null) {
-			oval_collection_add(definition->reference,
-					    (void *)reference);
-		}
 		return_code =
 		    oval_reference_parse_tag(reader, context,
-					     &reference_consumer, NULL);
+					     &_oval_definition_reference_consumer,
+					     user);
 	} else {
 		int linno = xmlTextReaderGetParserLineNumber(reader);
 		printf
diff --git a/src/OVAL/oval_entity.c b/src/OVAL/oval_entity.c
index df69000..9a94a00 100644
--- a/src/OVAL/oval_entity.c
+++ b/src/OVAL/oval_entity.c
@@ -169,6 +169,18 @@ void set_oval_entity_name(struct oval_entity *entity, char *name)
 	entity->name = name;
 }
 
+/* I don't know cleaner solution to get data and avoid
+ * executable stack :( */
+void oval_entity_consume_varref(char *data, void *varref) {
+	char **p = (char **) varref;
+        (*p) = data;
+}
+
+void oval_entity_consume_value(struct oval_value *use_value, void *value) {
+	char **p = (char **) value;
+	(*p) = use_value;
+}
+
 //typedef void (*oval_entity_consumer)(struct oval_entity_node*, void*);
 int oval_entity_parse_tag(xmlTextReaderPtr reader,
 			  struct oval_parser_context *context,
@@ -191,13 +203,13 @@ int oval_entity_parse_tag(xmlTextReaderPtr reader,
 		if (varref == NULL) {
 			struct oval_object_model *model =
 			    oval_parser_context_model(context);
-			void consume_varref(char *varref, void *null) {
-				variable = get_oval_variable(model, varref);
-			}
+			char * varref;
+
 			varref_type = OVAL_ENTITY_VARREF_ELEMENT;
 			return_code =
 			    oval_parser_text_value(reader, context,
-						   &consume_varref, NULL);
+						   &oval_entity_consume_varref, (void *) &varref);
+			variable = get_oval_variable(model, varref);
 		} else {
 			struct oval_object_model *model =
 			    oval_parser_context_model(context);
@@ -208,12 +220,9 @@ int oval_entity_parse_tag(xmlTextReaderPtr reader,
 		value = NULL;
 	} else if (varref == NULL) {
 		variable = NULL;
-		void consume_value(struct oval_value *use_value, void *null) {
-			value = use_value;
-		}
 		varref_type = OVAL_ENTITY_VARREF_NONE;
 		return_code =
-		    oval_value_parse_tag(reader, context, &consume_value, NULL);
+		    oval_value_parse_tag(reader, context, &oval_entity_consume_value, (void *) &value);
 	} else {
 		struct oval_object_model *model =
 		    oval_parser_context_model(context);
diff --git a/src/OVAL/oval_object.c b/src/OVAL/oval_object.c
index 8d85810..cabd185 100644
--- a/src/OVAL/oval_object.c
+++ b/src/OVAL/oval_object.c
@@ -186,14 +186,29 @@ void add_oval_object_behaviors(struct oval_object *object,
 	oval_collection_add(object->behaviors, (void *)behavior);
 }
 
+void _oval_object_note_consumer(char *text, void *user) {
+	struct oval_object *object = (struct oval_object *)user;
+	add_oval_object_notes(object, text);
+}
+
+void _oval_object_behavior_consumer(struct oval_behavior *behavior, void *user) 
+{
+	struct oval_object *object = (struct oval_object *)user;
+	add_oval_object_behaviors(object, behavior);
+}
+
+void _oval_object_content_consumer(struct oval_object_content *content, 
+				   void *user) 
+{
+	struct oval_object *object = (struct oval_object *)user;
+	add_oval_object_object_content(object, content);
+}
+
 int _oval_object_parse_notes(xmlTextReaderPtr reader,
 			     struct oval_parser_context *context, void *user)
 {
-	struct oval_object *object = (struct oval_object *)user;
-	void note_consumer(char *text, void *null) {
-		add_oval_object_notes(object, text);
-	}
-	return oval_parser_text_value(reader, context, &note_consumer, NULL);
+	return oval_parser_text_value(reader, context, 
+			              &_oval_object_note_consumer, user);
 }
 
 int _oval_object_parse_tag(xmlTextReaderPtr reader,
@@ -206,24 +221,18 @@ int _oval_object_parse_tag(xmlTextReaderPtr reader,
 	if ((strcmp(tagname, "notes") == 0)) {
 		return_code =
 		    oval_parser_parse_tag(reader, context,
-					  &_oval_object_parse_notes, object);
+					  &_oval_object_parse_notes, user);
 	} else if (strcmp(tagname, "behaviors") == 0) {
-		void behavior_consumer(struct oval_behavior *behavior,
-				       void *null) {
-			add_oval_object_behaviors(object, behavior);
-		}
 		return_code =
 		    oval_behavior_parse_tag(reader, context,
 					    oval_object_family(object),
-					    &behavior_consumer, NULL);
+					    &_oval_object_behavior_consumer, 
+					    user);
 	} else {
-		void content_consumer(struct oval_object_content *content,
-				      void *null) {
-			add_oval_object_object_content(object, content);
-		}
 		return_code =
 		    oval_object_content_parse_tag(reader, context,
-						  &content_consumer, NULL);
+						  &_oval_object_content_consumer, 
+						  user);
 	}
 	if (return_code != 1) {
 		int line = xmlTextReaderGetParserLineNumber(reader);
diff --git a/src/OVAL/oval_objectContent.c b/src/OVAL/oval_objectContent.c
index e7c677a..e652d3f 100644
--- a/src/OVAL/oval_objectContent.c
+++ b/src/OVAL/oval_objectContent.c
@@ -169,6 +169,20 @@ void set_oval_object_content_entity(struct oval_object_content *, struct oval_en
 void set_oval_object_content_varCheck(struct oval_object_content *, oval_check_enum);	//TODO//type == OVAL_OBJECTCONTENT_ENTITY
 void set_oval_object_content_set(struct oval_object_content *, struct oval_set *);	//TODO   //type == OVAL_OBJECTCONTENT_SET
 
+void oval_object_content_consume_entity(struct oval_entity *entity,
+		    void *user) 
+{
+	struct oval_object_content_ENTITY *content_entity =
+                            (struct oval_object_content_ENTITY *) user;
+	content_entity->entity = entity;
+}
+
+void oval_object_content_consume_set(struct oval_set *set, void *user) {
+	struct oval_object_content_SET *content_set =
+                            (struct oval_object_content_SET *) user;
+	content_set->set = set;
+}
+
 //typedef void (*oval_object_content_consumer)(struct oval_object_content*,void*);
 int oval_object_content_parse_tag(xmlTextReaderPtr reader,
 				  struct oval_parser_context *context,
@@ -188,13 +202,11 @@ int oval_object_content_parse_tag(xmlTextReaderPtr reader,
 	case OVAL_OBJECTCONTENT_ENTITY:{
 			struct oval_object_content_ENTITY *content_entity =
 			    (struct oval_object_content_ENTITY *)content;
-			void consume_entity(struct oval_entity *entity,
-					    void *null) {
-				content_entity->entity = entity;
-			}
+
 			return_code =
 			    oval_entity_parse_tag(reader, context,
-						  &consume_entity, NULL);
+						  &oval_object_content_consume_entity, 
+						  content);
 			content_entity->varCheck =
 			    oval_check_parse(reader, "var_check",
 					     OVAL_CHECK_ALL);
@@ -203,12 +215,10 @@ int oval_object_content_parse_tag(xmlTextReaderPtr reader,
 	case OVAL_OBJECTCONTENT_SET:{
 			struct oval_object_content_SET *content_set =
 			    (struct oval_object_content_SET *)content;
-			void consume_set(struct oval_set *set, void *null) {
-				content_set->set = set;
-			}
 			return_code =
-			    oval_set_parse_tag(reader, context, &consume_set,
-					       NULL);
+			    oval_set_parse_tag(reader, context, 
+					       &oval_object_content_consume_set,
+					       content);
 		};
 		break;
 	}
diff --git a/src/OVAL/oval_set.c b/src/OVAL/oval_set.c
index 791960f..6be57b3 100644
--- a/src/OVAL/oval_set.c
+++ b/src/OVAL/oval_set.c
@@ -188,6 +188,31 @@ void add_oval_set_filters(struct oval_set *set, struct oval_state *filter)
 	oval_collection_add(collective->filters, (void *)filter);
 }
 
+void _oval_set_consume_set(struct oval_set *subset, void *user) 
+{
+	struct oval_set *set = (struct oval_set *)user;
+	add_oval_set_subsets(set, subset);
+}
+
+void _oval_set_consume_ref(char *text, void *user)
+{
+        char **ref = (char **) user;
+
+        if (*ref == NULL)
+                *ref = text;
+        else {
+                int size = strlen(*ref) + strlen(text) + 1;
+                char *newtext =
+                    (char *)malloc(size * sizeof(char *));
+                *newtext = 0;
+                strcat(newtext, *ref);
+                strcat(newtext, text);
+                free(*ref);
+                free(text);
+                *ref = newtext;
+        }
+}
+
 //typedef int (*oval_xml_tag_parser)(xmlTextReaderPtr, struct oval_parser_context*, void*);
 int _oval_set_parse_tag(xmlTextReaderPtr reader,
 			struct oval_parser_context *context, void *user)
@@ -202,37 +227,36 @@ int _oval_set_parse_tag(xmlTextReaderPtr reader,
 		if (set->type == OVAL_SET_UNKNOWN) {
 			set_oval_set_type(set, OVAL_SET_AGGREGATE);
 		}
-		void consume_set(struct oval_set *subset, void *null) {
-			add_oval_set_subsets(set, subset);
-		}
 		return_code =
-		    oval_set_parse_tag(reader, context, &consume_set, NULL);
+		    oval_set_parse_tag(reader, context, &_oval_set_consume_set, user);
 	} else {
 		if (set->type == OVAL_SET_UNKNOWN) {
 			set_oval_set_type(set, OVAL_SET_COLLECTIVE);
 		}
 		if (strcmp(tagname, "object_reference") == 0) {
-			void consume_object_ref(char *objref, void *null) {
-				struct oval_object_model *model =
-				    oval_parser_context_model(context);
-				struct oval_object *object =
-				    get_oval_object_new(model, objref);
-				add_oval_set_objects(set, object);
-			}
+			char *objref = NULL;
+			struct oval_object *object;
+			struct oval_object_model *model = 
+			    oval_parser_context_model(context);
+
 			return_code =
 			    oval_parser_text_value(reader, context,
-						   &consume_object_ref, NULL);
+						   &_oval_set_consume_ref, (void*) &objref);
+
+			object = get_oval_object_new(model, objref);
+			add_oval_set_objects(set, object);
+
 		} else if (strcmp(tagname, "filter") == 0) {
-			void consume_state_ref(char *steref, void *null) {
-				struct oval_object_model *model =
-				    oval_parser_context_model(context);
-				struct oval_state *state =
-				    get_oval_state_new(model, steref);
-				add_oval_set_filters(set, state);
-			}
+			char *steref = NULL;
+			struct oval_state *state;
+			struct oval_object_model *model =
+			    oval_parser_context_model(context);
+
 			return_code =
 			    oval_parser_text_value(reader, context,
-						   &consume_state_ref, NULL);
+						   &_oval_set_consume_ref, (void*) &steref);
+			state = get_oval_state_new(model, steref);
+			add_oval_set_filters(set, state);
 		} else {
 			int line = xmlTextReaderGetParserLineNumber(reader);
 			printf
diff --git a/src/OVAL/oval_state.c b/src/OVAL/oval_state.c
index 4a53333..3ac8198 100644
--- a/src/OVAL/oval_state.c
+++ b/src/OVAL/oval_state.c
@@ -176,14 +176,23 @@ void set_oval_state_version(struct oval_state *state, int version)
 	state->version = version;
 }
 
+void _oval_state_note_consumer(char *text, void *user) 
+{
+	struct oval_state *state = (struct oval_state *)user;
+	add_oval_state_notes(state, text);
+}
+
+void _oval_state_entity_consumer(struct oval_entity *entity, void *user) 
+{
+	struct oval_state *state = (struct oval_state *) user;
+	oval_collection_add(state->entities, (void *)entity);
+}
+
 int _oval_state_parse_notes(xmlTextReaderPtr reader,
 			    struct oval_parser_context *context, void *user)
 {
-	struct oval_state *state = (struct oval_state *)user;
-	void note_consumer(char *text, void *null) {
-		add_oval_state_notes(state, text);
-	}
-	return oval_parser_text_value(reader, context, &note_consumer, NULL);
+	return oval_parser_text_value(reader, context, 
+			              &_oval_state_note_consumer, user);
 }
 
 int _oval_state_parse_tag(xmlTextReaderPtr reader,
@@ -196,14 +205,11 @@ int _oval_state_parse_tag(xmlTextReaderPtr reader,
 	if ((strcmp(tagname, "notes") == 0)) {
 		return_code =
 		    oval_parser_parse_tag(reader, context,
-					  &_oval_state_parse_notes, state);
+					  &_oval_state_note_consumer, user);
 	} else {
-		void consume_entity(struct oval_entity *entity, void *null) {
-			oval_collection_add(state->entities, (void *)entity);
-		}
 		return_code =
-		    oval_entity_parse_tag(reader, context, &consume_entity,
-					  NULL);
+		    oval_entity_parse_tag(reader, context, 
+					  &_oval_state_entity_consumer, user);
 	}
 	if (return_code != 1) {
 		int line = xmlTextReaderGetParserLineNumber(reader);
diff --git a/src/OVAL/oval_test.c b/src/OVAL/oval_test.c
index 5484757..0b6dc4d 100644
--- a/src/OVAL/oval_test.c
+++ b/src/OVAL/oval_test.c
@@ -211,14 +211,16 @@ void add_oval_test_notes(struct oval_test *test, char *note)
 	oval_collection_add(test->notes, (void *)note);
 }
 
+void _oval_test_note_consumer(char *text, void *user) {
+	struct oval_test *test = (struct oval_test *)user;
+	add_oval_test_notes(test, text);
+}
+
 int _oval_test_parse_notes(xmlTextReaderPtr reader,
 			   struct oval_parser_context *context, void *user)
 {
-	struct oval_test *test = (struct oval_test *)user;
-	void note_consumer(char *text, void *null) {
-		add_oval_test_notes(test, text);
-	}
-	return oval_parser_text_value(reader, context, &note_consumer, NULL);
+	return oval_parser_text_value(reader, context, 
+				      &_oval_test_note_consumer, user);
 }
 
 int _oval_test_parse_tag(xmlTextReaderPtr reader,
diff --git a/src/OVAL/oval_value.c b/src/OVAL/oval_value.c
index cdfb698..4c0b347 100644
--- a/src/OVAL/oval_value.c
+++ b/src/OVAL/oval_value.c
@@ -107,6 +107,11 @@ void set_oval_value_text(struct oval_value *value, char *text)
 	value->text = text;
 }
 
+void oval_value_consume_text(char *string, void *user) {
+	char **text = (char **) user;
+	*text = string;
+}
+
 int oval_value_parse_tag(xmlTextReaderPtr reader,
 			 struct oval_parser_context *context,
 			 oval_value_consumer consumer, void *user)
@@ -121,12 +126,9 @@ int oval_value_parse_tag(xmlTextReaderPtr reader,
 		text = NULL;
 		return_code = 1;
 	} else {
-		void consume_text(char *string, void *null) {
-			text = string;
-		}
 		return_code =
-		    oval_parser_text_value(reader, context, &consume_text,
-					   NULL);
+		    oval_parser_text_value(reader, context, &oval_value_consume_text,
+					   (void*) &text);
 	}
 	set_oval_value_datatype(value, datatype);
 	set_oval_value_text(value, text);
diff --git a/src/OVAL/oval_variable.c b/src/OVAL/oval_variable.c
index 0edb1b3..988ef87 100644
--- a/src/OVAL/oval_variable.c
+++ b/src/OVAL/oval_variable.c
@@ -230,6 +230,11 @@ void set_oval_variable_component(struct oval_variable *variable,
 	}
 }
 
+void _oval_variable_component_consumer(struct oval_component *component, void *user) {
+	struct oval_variable *variable = (struct oval_variable *) user;
+	set_oval_variable_component(variable, component);
+}
+
 int _oval_variable_parse_local_tag(xmlTextReaderPtr reader,
 				   struct oval_parser_context *context,
 				   void *user)
@@ -237,12 +242,12 @@ int _oval_variable_parse_local_tag(xmlTextReaderPtr reader,
 	struct oval_variable *variable = (struct oval_variable *)user;
 	xmlChar *tagname = xmlTextReaderName(reader);
 	xmlChar *namespace = xmlTextReaderNamespaceUri(reader);
-	void component_consumer(struct oval_component *component, void *null) {
-		set_oval_variable_component(variable, component);
-	}
+
+
 	int return_code =
-	    oval_component_parse_tag(reader, context, &component_consumer,
-				     NULL);
+	    oval_component_parse_tag(reader, context, 
+				     &_oval_variable_component_consumer,
+				     user);
 	if (return_code != 1) {
 		int line = xmlTextReaderGetParserLineNumber(reader);
 		printf