C89

svn path=/trunk/hubbub/; revision=5843

7 files changed, 58 insertions, 46 deletions

diff --git a/src/treebuilder/generic_rcdata.c b/src/treebuilder/generic_rcdata.c
index 44d29c8..1daf80f 100644
--- a/src/treebuilder/generic_rcdata.c
+++ b/src/treebuilder/generic_rcdata.c
@@ -37,6 +37,8 @@ hubbub_error handle_generic_rcdata(hubbub_treebuilder *treebuilder,
 	case HUBBUB_TOKEN_CHARACTER:
 	{
 		hubbub_string chars = token->data.character;
+		int success;
+		void *text, *appended;
 
 		if (treebuilder->context.strip_leading_lr) {
 			if (chars.ptr[0] == '\n') {
@@ -51,9 +53,6 @@ hubbub_error handle_generic_rcdata(hubbub_treebuilder *treebuilder,
 			break;
 
 
-		int success;
-		void *text, *appended;
-
 		success = treebuilder->tree_handler->create_text(
 				treebuilder->tree_handler->ctx,
 				&chars,
diff --git a/src/treebuilder/in_body.c b/src/treebuilder/in_body.c
index e63712d..f9fbfe7 100644
--- a/src/treebuilder/in_body.c
+++ b/src/treebuilder/in_body.c
@@ -113,6 +113,7 @@ hubbub_error handle_in_body(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token)
 {
 	hubbub_error err = HUBBUB_OK;
+	uint32_t i;
 
 #if !defined(NDEBUG) && defined(DEBUG_IN_BODY)
 	fprintf(stdout, "Processing token %d\n", token->type);
@@ -145,7 +146,7 @@ hubbub_error handle_in_body(hubbub_treebuilder *treebuilder,
 		err = process_end_tag(treebuilder, token);
 		break;
 	case HUBBUB_TOKEN_EOF:
-		for (uint32_t i = treebuilder->context.current_node; 
+		for (i = treebuilder->context.current_node; 
 				i > 0; i--) {
 			element_type type = 
 				treebuilder->context.element_stack[i].type;
@@ -873,6 +874,7 @@ void process_isindex_in_body(hubbub_treebuilder *treebuilder,
 
 	/* First up, clone the token's attributes */
 	if (token->data.tag.n_attributes > 0) {
+		uint32_t i;
 		attrs = treebuilder->alloc(NULL,
 				(token->data.tag.n_attributes + 1) *
 						sizeof(hubbub_attribute),
@@ -882,7 +884,7 @@ void process_isindex_in_body(hubbub_treebuilder *treebuilder,
 			return;
 		}
 
-		for (uint32_t i = 0; i < token->data.tag.n_attributes; i++) {
+		for (i = 0; i < token->data.tag.n_attributes; i++) {
 			hubbub_attribute *attr = &token->data.tag.attributes[i];
 			const uint8_t *name = attr->name.ptr;
 
@@ -1271,10 +1273,21 @@ void process_0presentational_in_body(hubbub_treebuilder *treebuilder,
 	while (true) {
 		element_context *stack = treebuilder->context.element_stack;
 
-		/* 1 */
 		formatting_list_entry *entry;
 		uint32_t formatting_element;
+		uint32_t common_ancestor;
+		uint32_t furthest_block;
+		bookmark bookmark;
+		uint32_t last_node;
+		void *reparented;
+		void *fe_clone = NULL;
+		void *clone_appended = NULL;
+		hubbub_ns ons;
+		element_type otype;
+		void *onode;
+		uint32_t oindex;
 
+		/* 1 */
 		if (!aa_find_and_validate_formatting_element(treebuilder,
 				type, &entry))
 			return;
@@ -1286,34 +1299,26 @@ void process_0presentational_in_body(hubbub_treebuilder *treebuilder,
 		formatting_element = entry->stack_index;
 
 		/* 2 & 3 */
-		uint32_t furthest_block;
-
 		if (!aa_find_furthest_block(treebuilder,
 				entry, &furthest_block))
 			return;
 
 		/* 4 */
-		uint32_t common_ancestor = formatting_element - 1;
+		common_ancestor = formatting_element - 1;
 
 		/* 5 */
 		aa_remove_from_parent(treebuilder, stack[furthest_block].node);
 
 		/* 6 */
-		bookmark bookmark;
-
 		bookmark.prev = entry->prev;
 		bookmark.next = entry->next;
 
 		/* 7 */
-		uint32_t last_node;
-
 		aa_find_bookmark_location_reparenting_misnested(treebuilder,
 				formatting_element, &furthest_block,
 				&bookmark, &last_node);
 
 		/* 8 */
-		void *reparented;
-
 		if (stack[common_ancestor].type == TABLE ||
 				stack[common_ancestor].type == TBODY ||
 				stack[common_ancestor].type == TFOOT ||
@@ -1330,8 +1335,8 @@ void process_0presentational_in_body(hubbub_treebuilder *treebuilder,
 		 * previously using, then have it take the place of the other
 		 * one in the formatting list and stack. */
 		if (reparented != stack[last_node].node) {
-			for (struct formatting_list_entry *node_entry = 
-				treebuilder->context.formatting_list_end;
+			struct formatting_list_entry *node_entry;
+			for (node_entry = treebuilder->context.formatting_list_end;
 					node_entry != NULL; 
 					node_entry = node_entry->prev) {
 				if (node_entry->stack_index == last_node) {
@@ -1351,8 +1356,6 @@ void process_0presentational_in_body(hubbub_treebuilder *treebuilder,
 		}
 
 		/* 9 */
-		void *fe_clone = NULL;
-
 		treebuilder->tree_handler->clone_node(
 				treebuilder->tree_handler->ctx,
 				entry->details.node, false, &fe_clone);
@@ -1363,8 +1366,6 @@ void process_0presentational_in_body(hubbub_treebuilder *treebuilder,
 				stack[furthest_block].node, fe_clone);
 
 		/* 11 */
-		void *clone_appended = NULL;
-
 		treebuilder->tree_handler->append_child(
 				treebuilder->tree_handler->ctx,
 				stack[furthest_block].node, fe_clone,
@@ -1398,11 +1399,6 @@ void process_0presentational_in_body(hubbub_treebuilder *treebuilder,
 		stack[furthest_block + 1].node = clone_appended;
 
 		/* 12 */
-		hubbub_ns ons;
-		element_type otype;
-		void *onode;
-		uint32_t oindex;
-
 		formatting_list_remove(treebuilder, entry,
 				&ons, &otype, &onode, &oindex);
 
@@ -1628,6 +1624,9 @@ void aa_find_bookmark_location_reparenting_misnested(
 	node = last = fb = *furthest_block;
 
 	while (true) {
+		bool children = false;
+		void *reparented;
+
 		/* i */
 		node--;
 
@@ -1667,8 +1666,6 @@ void aa_find_bookmark_location_reparenting_misnested(
 		}
 
 		/* v */
-		bool children = false;
-
 		treebuilder->tree_handler->has_children(
 				treebuilder->tree_handler->ctx,
 				node_entry->details.node, &children);
@@ -1678,7 +1675,7 @@ void aa_find_bookmark_location_reparenting_misnested(
 		}
 
 		/* vi */
-		void *reparented = aa_reparent_node(treebuilder,
+		reparented = aa_reparent_node(treebuilder,
 				stack[last].node, stack[node].node);
 		/* If the reparented node is not the same as the one we were
 		 * previously using, then have it take the place of the other
@@ -1728,6 +1725,7 @@ void aa_remove_element_stack_item(hubbub_treebuilder *treebuilder,
 		uint32_t index, uint32_t limit)
 {
 	element_context *stack = treebuilder->context.element_stack;
+	uint32_t n;
 
 	assert(index < limit);
 	assert(limit <= treebuilder->context.current_node);
@@ -1737,7 +1735,7 @@ void aa_remove_element_stack_item(hubbub_treebuilder *treebuilder,
 	 * entries. If found, update the corresponding
 	 * formatting list entry's stack index to match the
 	 * new stack location */
-	for (uint32_t n = index + 1; n <= limit; n++) {
+	for (n = index + 1; n <= limit; n++) {
 		if (is_formatting_element(stack[n].type) ||
 				(is_scoping_element(stack[n].type) &&
 				stack[n].type != HTML &&
diff --git a/src/treebuilder/in_foreign_content.c b/src/treebuilder/in_foreign_content.c
index 4441433..8cb17d8 100644
--- a/src/treebuilder/in_foreign_content.c
+++ b/src/treebuilder/in_foreign_content.c
@@ -142,15 +142,17 @@ static const case_changes svg_tagnames[] = {
 void adjust_svg_attributes(hubbub_treebuilder *treebuilder,
 		hubbub_tag *tag)
 {
+	size_t i;
 	UNUSED(treebuilder);
 
-	for (size_t i = 0; i < tag->n_attributes; i++) {
+	for (i = 0; i < tag->n_attributes; i++) {
 		hubbub_attribute *attr = &tag->attributes[i];
 
 		const uint8_t *name = attr->name.ptr;
 		size_t len = attr->name.len;
+		size_t j;
 
-		for (size_t j = 0; j < N_ELEMENTS(svg_attributes); j++) {
+		for (j = 0; j < N_ELEMENTS(svg_attributes); j++) {
 			if (hubbub_string_match(name, len,
 					(uint8_t *)svg_attributes[j].attr,
 					svg_attributes[j].len)) {
@@ -172,10 +174,11 @@ void adjust_svg_tagname(hubbub_treebuilder *treebuilder,
 {
 	const uint8_t *name = tag->name.ptr;
 	size_t len = tag->name.len;
+	size_t i;
 
 	UNUSED(treebuilder);
 
-	for (size_t i = 0; i < N_ELEMENTS(svg_tagnames); i++) {
+	for (i = 0; i < N_ELEMENTS(svg_tagnames); i++) {
 		if (hubbub_string_match(name, len,
 				(uint8_t *)svg_tagnames[i].attr,
 				svg_tagnames[i].len)) {
@@ -198,9 +201,10 @@ void adjust_svg_tagname(hubbub_treebuilder *treebuilder,
 void adjust_foreign_attributes(hubbub_treebuilder *treebuilder,
 		hubbub_tag *tag)
 {
+	size_t i;
 	UNUSED(treebuilder);
 
-	for (size_t i = 0; i < tag->n_attributes; i++) {
+	for (i = 0; i < tag->n_attributes; i++) {
 		hubbub_attribute *attr = &tag->attributes[i];
 		const uint8_t *name = attr->name.ptr;
 
diff --git a/src/treebuilder/in_head.c b/src/treebuilder/in_head.c
index ba4daf5..d6147f6 100644
--- a/src/treebuilder/in_head.c
+++ b/src/treebuilder/in_head.c
@@ -29,6 +29,10 @@
 static hubbub_error process_meta_in_head(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token)
 {
+	uint16_t charset_enc = 0;
+	uint16_t content_type_enc = 0;
+	size_t i;
+
 	insert_element_no_push(treebuilder, &token->data.tag);
 
 	/** \todo ack sc flag */
@@ -38,10 +42,7 @@ static hubbub_error process_meta_in_head(hubbub_treebuilder *treebuilder,
 		return HUBBUB_OK;
 #endif
 
-	uint16_t charset_enc = 0;
-	uint16_t content_type_enc = 0;
-
-	for (size_t i = 0; i < token->data.tag.n_attributes; i++) {
+	for (i = 0; i < token->data.tag.n_attributes; i++) {
 		hubbub_attribute *attr = &token->data.tag.attributes[i];
 
 		if (hubbub_string_match(attr->name.ptr, attr->name.len,
diff --git a/src/treebuilder/in_table.c b/src/treebuilder/in_table.c
index a080f87..0530ee3 100644
--- a/src/treebuilder/in_table.c
+++ b/src/treebuilder/in_table.c
@@ -46,7 +46,8 @@ static inline void clear_stack_table_context(hubbub_treebuilder *treebuilder)
 static inline bool process_input_in_table(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token)
 {
-	for (size_t i = 0; i < token->data.tag.n_attributes; i++) {
+	size_t i;
+	for (i = 0; i < token->data.tag.n_attributes; i++) {
 		hubbub_attribute *attr = &token->data.tag.attributes[i];
 
 		if (!hubbub_string_match_ci(attr->value.ptr, attr->value.len,
diff --git a/src/treebuilder/initial.c b/src/treebuilder/initial.c
index 0ea071a..5e274c7 100644
--- a/src/treebuilder/initial.c
+++ b/src/treebuilder/initial.c
@@ -92,11 +92,12 @@ static bool starts_with(const uint8_t *a, size_t a_len, const uint8_t *b,
 		size_t b_len)
 {
 	uint8_t z1, z2;
+	const uint8_t *s1, *s2;
 
 	if (a_len < b_len)
 		return false;
 
-	for (const uint8_t *s1 = a, *s2 = b; b_len > 0; s1++, s2++, b_len--)
+	for (s1 = a, s2 = b; b_len > 0; s1++, s2++, b_len--)
 	{
 		z1 = (*s1 & ~0x20);
 		z2 = (*s2 & ~0x20);
@@ -242,6 +243,7 @@ hubbub_error handle_initial(hubbub_treebuilder *treebuilder, const hubbub_token
 	{
 		int success;
 		void *doctype, *appended;
+		const hubbub_doctype *cdoc;
 
 		/** \todo parse error */
 
@@ -271,7 +273,7 @@ hubbub_error handle_initial(hubbub_treebuilder *treebuilder, const hubbub_token
 		treebuilder->tree_handler->unref_node(
 				treebuilder->tree_handler->ctx, doctype);
 
-		const hubbub_doctype *cdoc = &token->data.doctype;
+		cdoc = &token->data.doctype;
 
 		/* Work out whether we need quirks mode or not */
 		if (cdoc->force_quirks == true ||
diff --git a/src/treebuilder/treebuilder.c b/src/treebuilder/treebuilder.c
index 59fc4e1..3da9ffa 100644
--- a/src/treebuilder/treebuilder.c
+++ b/src/treebuilder/treebuilder.c
@@ -172,6 +172,8 @@ hubbub_error hubbub_treebuilder_destroy(hubbub_treebuilder *treebuilder)
 
 	/* Clean up context */
 	if (treebuilder->tree_handler != NULL) {
+		uint32_t n;
+
 		if (treebuilder->context.head_element != NULL) {
 			treebuilder->tree_handler->unref_node(
 					treebuilder->tree_handler->ctx,
@@ -196,7 +198,7 @@ hubbub_error hubbub_treebuilder_destroy(hubbub_treebuilder *treebuilder)
 					treebuilder->context.collect.node);
 		}
 
-		for (uint32_t n = treebuilder->context.current_node; 
+		for (n = treebuilder->context.current_node; 
 				n > 0; n--) {
 			treebuilder->tree_handler->unref_node(
 				treebuilder->tree_handler->ctx,
@@ -618,6 +620,7 @@ void reconstruct_active_formatting_list(hubbub_treebuilder *treebuilder)
 		element_type prev_type;
 		void *prev_node;
 		uint32_t prev_stack_index;
+		bool foster;
 
 		element_type type = current_node(treebuilder);
 
@@ -631,7 +634,7 @@ void reconstruct_active_formatting_list(hubbub_treebuilder *treebuilder)
 			return;
 		}
 
-		bool foster = treebuilder->context.in_table_foster &&
+		foster = treebuilder->context.in_table_foster &&
 				(type == TABLE || type == TBODY ||
 					type == TFOOT || type == THEAD ||
 					type == TR);
@@ -973,12 +976,13 @@ element_type element_type_from_name(hubbub_treebuilder *treebuilder,
 {
 	const uint8_t *name = tag_name->ptr;
 	size_t len = tag_name->len;
+	uint32_t i;
 
 	UNUSED(treebuilder);
 
 	/** \todo optimise this */
 
-	for (uint32_t i = 0; i < N_ELEMENTS(name_type_map); i++) {
+	for (i = 0; i < N_ELEMENTS(name_type_map); i++) {
 		if (name_type_map[i].len != len)
 			continue;
 
@@ -1157,8 +1161,9 @@ bool element_stack_pop_until(hubbub_treebuilder *treebuilder,
 uint32_t current_table(hubbub_treebuilder *treebuilder)
 {
 	element_context *stack = treebuilder->context.element_stack;
+	size_t t;
 
-	for (size_t t = treebuilder->context.current_node; t != 0; t--) {
+	for (t = treebuilder->context.current_node; t != 0; t--) {
 		if (stack[t].type == TABLE)
 			return t;
 	}
@@ -1411,7 +1416,9 @@ void formatting_list_dump(hubbub_treebuilder *treebuilder, FILE *fp)
  */
 const char *element_type_to_name(element_type type)
 {
-	for (size_t i = 0; 
+	size_t i;
+
+	for (i = 0; 
 			i < sizeof(name_type_map) / sizeof(name_type_map[0]);
 			i++) {
 		if (name_type_map[i].type == type)