large scale symbol renaming in C codecolm-barracuda-v3

using _ conventions for C, camelCase of C++

1 files changed, 163 insertions, 163 deletions

diff --git a/src/iter.c b/src/iter.c
index 92cd0669..ef7490ff 100644
--- a/src/iter.c
+++ b/src/iter.c
@@ -28,18 +28,18 @@
 #define true 1
 #define false 0
 
-void colm_init_list_iter( generic_iter_t *listIter, tree_t **stackRoot,
-		long argSize, long rootSize, const ref_t *rootRef, int genericId )
+void colm_init_list_iter( generic_iter_t *list_iter, tree_t **stack_root,
+		long arg_size, long root_size, const ref_t *root_ref, int generic_id )
 {
-	listIter->type = IT_Tree;
-	listIter->rootRef = *rootRef;
-	listIter->stackRoot = stackRoot;
-	listIter->yieldSize = 0;
-	listIter->rootSize = rootSize;
-	listIter->ref.kid = 0;
-	listIter->ref.next = 0;
-	listIter->argSize = argSize;
-	listIter->genericId = genericId;
+	list_iter->type = IT_Tree;
+	list_iter->root_ref = *root_ref;
+	list_iter->stack_root = stack_root;
+	list_iter->yield_size = 0;
+	list_iter->root_size = root_size;
+	list_iter->ref.kid = 0;
+	list_iter->ref.next = 0;
+	list_iter->arg_size = arg_size;
+	list_iter->generic_id = generic_id;
 }
 
 void colm_list_iter_destroy( program_t *prg, tree_t ***psp, generic_iter_t *iter )
@@ -47,10 +47,10 @@ void colm_list_iter_destroy( program_t *prg, tree_t ***psp, generic_iter_t *iter
 	if ( (int)iter->type != 0 ) {
 		int i;
 		tree_t **sp = *psp;
-		long curStackSize = vm_ssize() - iter->rootSize;
-		assert( iter->yieldSize == curStackSize );
-		vm_popn( iter->yieldSize );
-		for ( i = 0; i < iter->argSize; i++ )
+		long cur_stack_size = vm_ssize() - iter->root_size;
+		assert( iter->yield_size == cur_stack_size );
+		vm_popn( iter->yield_size );
+		for ( i = 0; i < iter->arg_size; i++ )
 			colm_tree_downref( prg, sp, vm_pop_tree() );
 		iter->type = 0;
 		*psp = sp;
@@ -60,11 +60,11 @@ void colm_list_iter_destroy( program_t *prg, tree_t ***psp, generic_iter_t *iter
 tree_t *colm_list_iter_advance( program_t *prg, tree_t ***psp, generic_iter_t *iter )
 {
 	tree_t **sp = *psp;
-	assert( iter->yieldSize == (vm_ssize() - iter->rootSize) );
+	assert( iter->yield_size == (vm_ssize() - iter->root_size) );
 
 	if ( iter->ref.kid == 0 ) {
 		/* kid_t is zero, start from the root. */
-		list_t *list = *((list_t**)iter->rootRef.kid);
+		list_t *list = *((list_t**)iter->root_ref.kid);
 		iter->ref.kid = (kid_t*)list->head;
 		iter->ref.next = 0;
 
@@ -76,26 +76,26 @@ tree_t *colm_list_iter_advance( program_t *prg, tree_t ***psp, generic_iter_t *i
 		/* Have a previous item, continue searching from there. */
 		//iterFind( prg, psp, iter, false );
 
-		list_el_t *listEl = (list_el_t*)iter->ref.kid;
-		listEl = listEl->list_next;
-		iter->ref.kid = (kid_t*)listEl;
+		list_el_t *list_el = (list_el_t*)iter->ref.kid;
+		list_el = list_el->list_next;
+		iter->ref.kid = (kid_t*)list_el;
 		iter->ref.next = 0;
 	}
 
 	sp = *psp;
-	iter->yieldSize = vm_ssize() - iter->rootSize;
+	iter->yield_size = vm_ssize() - iter->root_size;
 
-	return (iter->ref.kid ? prg->trueVal : prg->falseVal );
+	return (iter->ref.kid ? prg->true_val : prg->false_val );
 }
 
 tree_t *colm_map_iter_advance( program_t *prg, tree_t ***psp, generic_iter_t *iter )
 {
 	tree_t **sp = *psp;
-	assert( iter->yieldSize == (vm_ssize() - iter->rootSize) );
+	assert( iter->yield_size == (vm_ssize() - iter->root_size) );
 
 	if ( iter->ref.kid == 0 ) {
 		/* kid_t is zero, start from the root. */
-		map_t *map = *((map_t**)iter->rootRef.kid);
+		map_t *map = *((map_t**)iter->root_ref.kid);
 		iter->ref.kid = (kid_t*)map->head;
 		iter->ref.next = 0;
 
@@ -107,91 +107,91 @@ tree_t *colm_map_iter_advance( program_t *prg, tree_t ***psp, generic_iter_t *it
 		/* Have a previous item, continue searching from there. */
 		//iterFind( prg, psp, iter, false );
 
-		map_el_t *mapEl = (map_el_t*)iter->ref.kid;
-		mapEl = mapEl->next;
-		iter->ref.kid = (kid_t*)mapEl;
+		map_el_t *map_el = (map_el_t*)iter->ref.kid;
+		map_el = map_el->next;
+		iter->ref.kid = (kid_t*)map_el;
 		iter->ref.next = 0;
 	}
 
 	sp = *psp;
-	iter->yieldSize = vm_ssize() - iter->rootSize;
+	iter->yield_size = vm_ssize() - iter->root_size;
 
-	return (iter->ref.kid ? prg->trueVal : prg->falseVal );
+	return (iter->ref.kid ? prg->true_val : prg->false_val );
 }
 
 tree_t *colm_list_iter_deref_cur( program_t *prg, generic_iter_t *iter )
 {
-	struct generic_info *gi = &prg->rtd->genericInfo[iter->genericId];
+	struct generic_info *gi = &prg->rtd->generic_info[iter->generic_id];
 	list_el_t *el = (list_el_t*)iter->ref.kid;
 	struct colm_struct *s = el != 0 ?
-			colm_struct_container( el, gi->elOffset ) : 0;
+			colm_struct_container( el, gi->el_offset ) : 0;
 	return (tree_t*)s;
 }
 
 value_t colm_viter_deref_cur( program_t *prg, generic_iter_t *iter )
 {
-	struct generic_info *gi = &prg->rtd->genericInfo[iter->genericId];
+	struct generic_info *gi = &prg->rtd->generic_info[iter->generic_id];
 	list_el_t *el = (list_el_t*)iter->ref.kid;
 	struct colm_struct *s = el != 0 ?
-			colm_struct_container( el, gi->elOffset ) : 0;
+			colm_struct_container( el, gi->el_offset ) : 0;
 
 	value_t value = colm_struct_get_field( s, value_t, 0 );
-	if ( gi->valueType == TYPE_TREE )
+	if ( gi->value_type == TYPE_TREE )
 		colm_tree_upref( (tree_t*)value );
 
 	return value;
 }
 
-void colm_init_tree_iter( tree_iter_t *treeIter, tree_t **stackRoot,
-		long argSize, long rootSize,
-		const ref_t *rootRef, int searchId )
+void colm_init_tree_iter( tree_iter_t *tree_iter, tree_t **stack_root,
+		long arg_size, long root_size,
+		const ref_t *root_ref, int search_id )
 {
-	treeIter->type = IT_Tree;
-	treeIter->rootRef = *rootRef;
-	treeIter->searchId = searchId;
-	treeIter->stackRoot = stackRoot;
-	treeIter->yieldSize = 0;
-	treeIter->rootSize = rootSize;
-	treeIter->ref.kid = 0;
-	treeIter->ref.next = 0;
-	treeIter->argSize = argSize;
+	tree_iter->type = IT_Tree;
+	tree_iter->root_ref = *root_ref;
+	tree_iter->search_id = search_id;
+	tree_iter->stack_root = stack_root;
+	tree_iter->yield_size = 0;
+	tree_iter->root_size = root_size;
+	tree_iter->ref.kid = 0;
+	tree_iter->ref.next = 0;
+	tree_iter->arg_size = arg_size;
 }
 
-void colm_init_rev_tree_iter( rev_tree_iter_t *revTriter, tree_t **stackRoot,
-		long argSize, long rootSize,
-		const ref_t *rootRef, int searchId, int children )
+void colm_init_rev_tree_iter( rev_tree_iter_t *rev_triter, tree_t **stack_root,
+		long arg_size, long root_size,
+		const ref_t *root_ref, int search_id, int children )
 {
-	revTriter->type = IT_RevTree;
-	revTriter->rootRef = *rootRef;
-	revTriter->searchId = searchId;
-	revTriter->stackRoot = stackRoot;
-	revTriter->yieldSize = children;
-	revTriter->rootSize = rootSize;
-	revTriter->kidAtYield = 0;
-	revTriter->children = children;
-	revTriter->ref.kid = 0;
-	revTriter->ref.next = 0;
-	revTriter->argSize = argSize;
+	rev_triter->type = IT_RevTree;
+	rev_triter->root_ref = *root_ref;
+	rev_triter->search_id = search_id;
+	rev_triter->stack_root = stack_root;
+	rev_triter->yield_size = children;
+	rev_triter->root_size = root_size;
+	rev_triter->kid_at_yield = 0;
+	rev_triter->children = children;
+	rev_triter->ref.kid = 0;
+	rev_triter->ref.next = 0;
+	rev_triter->arg_size = arg_size;
 }
 
-void initUserIter( user_iter_t *userIter, tree_t **stackRoot, long rootSize,
-		long argSize, long searchId )
+void init_user_iter( user_iter_t *user_iter, tree_t **stack_root, long root_size,
+		long arg_size, long search_id )
 {
-	userIter->type = IT_User;
-	userIter->stackRoot = stackRoot;
-	userIter->argSize = argSize;
-	userIter->yieldSize = 0;
-	userIter->rootSize = rootSize;
-	userIter->resume = 0;
-	userIter->frame = 0;
-	userIter->searchId = searchId;
-
-	userIter->ref.kid = 0;
-	userIter->ref.next = 0;
+	user_iter->type = IT_User;
+	user_iter->stack_root = stack_root;
+	user_iter->arg_size = arg_size;
+	user_iter->yield_size = 0;
+	user_iter->root_size = root_size;
+	user_iter->resume = 0;
+	user_iter->frame = 0;
+	user_iter->search_id = search_id;
+
+	user_iter->ref.kid = 0;
+	user_iter->ref.next = 0;
 }
 
 
-user_iter_t *colm_uiter_create( program_t *prg, tree_t ***psp, struct function_info *fi, long searchId )
+user_iter_t *colm_uiter_create( program_t *prg, tree_t ***psp, struct function_info *fi, long search_id )
 {
 	tree_t **sp = *psp;
 
@@ -199,27 +199,27 @@ user_iter_t *colm_uiter_create( program_t *prg, tree_t ***psp, struct function_i
 	void *mem = vm_ptop();
 	user_iter_t *uiter = mem;
 
-	tree_t **stackRoot = vm_ptop();
-	long rootSize = vm_ssize();
+	tree_t **stack_root = vm_ptop();
+	long root_size = vm_ssize();
 
-	initUserIter( uiter, stackRoot, rootSize, fi->argSize, searchId );
+	init_user_iter( uiter, stack_root, root_size, fi->arg_size, search_id );
 
 	*psp = sp;
 	return uiter;
 }
 
-void uiterInit( program_t *prg, tree_t **sp, user_iter_t *uiter, 
-		struct function_info *fi, int revertOn )
+void uiter_init( program_t *prg, tree_t **sp, user_iter_t *uiter, 
+		struct function_info *fi, int revert_on )
 {
 	/* Set up the first yeild so when we resume it starts at the beginning. */
 	uiter->ref.kid = 0;
-	uiter->yieldSize = vm_ssize() - uiter->rootSize;
+	uiter->yield_size = vm_ssize() - uiter->root_size;
 	//	uiter->frame = &uiter->stackRoot[-IFR_AA];
 
-	if ( revertOn )
-		uiter->resume = prg->rtd->frameInfo[fi->frameId].codeWV;
+	if ( revert_on )
+		uiter->resume = prg->rtd->frame_info[fi->frame_id].codeWV;
 	else
-		uiter->resume = prg->rtd->frameInfo[fi->frameId].codeWC;
+		uiter->resume = prg->rtd->frame_info[fi->frame_id].codeWC;
 }
 
 
@@ -228,10 +228,10 @@ void colm_tree_iter_destroy( program_t *prg, tree_t ***psp, tree_iter_t *iter )
 	if ( (int)iter->type != 0 ) {
 		int i;
 		tree_t **sp = *psp;
-		long curStackSize = vm_ssize() - iter->rootSize;
-		assert( iter->yieldSize == curStackSize );
-		vm_popn( iter->yieldSize );
-		for ( i = 0; i < iter->argSize; i++ )
+		long cur_stack_size = vm_ssize() - iter->root_size;
+		assert( iter->yield_size == cur_stack_size );
+		vm_popn( iter->yield_size );
+		for ( i = 0; i < iter->arg_size; i++ )
 			colm_tree_downref( prg, sp, vm_pop_tree() );
 		iter->type = 0;
 		*psp = sp;
@@ -243,10 +243,10 @@ void colm_rev_tree_iter_destroy( struct colm_program *prg, tree_t ***psp, rev_tr
 	if ( (int)riter->type != 0 ) {
 		int i;
 		tree_t **sp = *psp;
-		long curStackSize = vm_ssize() - riter->rootSize;
-		assert( riter->yieldSize == curStackSize );
-		vm_popn( riter->yieldSize );
-		for ( i = 0; i < riter->argSize; i++ )
+		long cur_stack_size = vm_ssize() - riter->root_size;
+		assert( riter->yield_size == cur_stack_size );
+		vm_popn( riter->yield_size );
+		for ( i = 0; i < riter->arg_size; i++ )
 			colm_tree_downref( prg, sp, vm_pop_tree() );
 		riter->type = 0;
 		*psp = sp;
@@ -260,10 +260,10 @@ void colm_uiter_destroy( program_t *prg, tree_t ***psp, user_iter_t *uiter )
 
 		/* We should always be coming from a yield. The current stack size will be
 		 * nonzero and the stack size in the iterator will be correct. */
-		long curStackSize = vm_ssize() - uiter->rootSize;
-		assert( uiter->yieldSize == curStackSize );
+		long cur_stack_size = vm_ssize() - uiter->root_size;
+		assert( uiter->yield_size == cur_stack_size );
 
-		vm_popn( uiter->yieldSize );
+		vm_popn( uiter->yield_size );
 		vm_popn( sizeof(user_iter_t) / sizeof(word_t) );
 
 		uiter->type = 0;
@@ -279,16 +279,16 @@ void colm_uiter_unwind( program_t *prg, tree_t ***psp, user_iter_t *uiter )
 
 		/* We should always be coming from a yield. The current stack size will be
 		 * nonzero and the stack size in the iterator will be correct. */
-		long curStackSize = vm_ssize() - uiter->rootSize;
-		assert( uiter->yieldSize == curStackSize );
+		long cur_stack_size = vm_ssize() - uiter->root_size;
+		assert( uiter->yield_size == cur_stack_size );
 
-		long argSize = uiter->argSize;
+		long arg_size = uiter->arg_size;
 
-		vm_popn( uiter->yieldSize );
+		vm_popn( uiter->yield_size );
 		vm_popn( sizeof(user_iter_t) / sizeof(word_t) );
 
 		/* The IN_PREP_ARGS stack data. */
-		vm_popn( argSize );
+		vm_popn( arg_size );
 		vm_pop_value();
 
 		uiter->type = 0;
@@ -297,43 +297,43 @@ void colm_uiter_unwind( program_t *prg, tree_t ***psp, user_iter_t *uiter )
 	}
 }
 
-tree_t *treeIterDerefCur( tree_iter_t *iter )
+tree_t *tree_iter_deref_cur( tree_iter_t *iter )
 {
 	return iter->ref.kid == 0 ? 0 : iter->ref.kid->tree;
 }
 
-void setTriterCur( program_t *prg, tree_iter_t *iter, tree_t *tree )
+void set_triter_cur( program_t *prg, tree_iter_t *iter, tree_t *tree )
 {
 	iter->ref.kid->tree = tree;
 }
 
-void setUiterCur( program_t *prg, user_iter_t *uiter, tree_t *tree )
+void set_uiter_cur( program_t *prg, user_iter_t *uiter, tree_t *tree )
 {
 	uiter->ref.kid->tree = tree;
 }
 
-void splitIterCur( program_t *prg, tree_t ***psp, tree_iter_t *iter )
+void split_iter_cur( program_t *prg, tree_t ***psp, tree_iter_t *iter )
 {
 	if ( iter->ref.kid == 0 )
 		return;
 	
-	splitRef( prg, psp, &iter->ref );
+	split_ref( prg, psp, &iter->ref );
 }
 
-void iterFind( program_t *prg, tree_t ***psp, tree_iter_t *iter, int tryFirst )
+void iter_find( program_t *prg, tree_t ***psp, tree_iter_t *iter, int try_first )
 {
-	int anyTree = iter->searchId == prg->rtd->anyId;
-	tree_t **top = iter->stackRoot;
+	int any_tree = iter->search_id == prg->rtd->any_id;
+	tree_t **top = iter->stack_root;
 	kid_t *child;
 	tree_t **sp = *psp;
 
 rec_call:
-	if ( tryFirst && ( iter->ref.kid->tree->id == iter->searchId || anyTree ) ) {
+	if ( try_first && ( iter->ref.kid->tree->id == iter->search_id || any_tree ) ) {
 		*psp = sp;
 		return;
 	}
 	else {
-		child = treeChild( prg, iter->ref.kid->tree );
+		child = tree_child( prg, iter->ref.kid->tree );
 		if ( child != 0 ) {
 			vm_contiguous( 2 );
 			vm_push_ref( iter->ref.next );
@@ -341,7 +341,7 @@ rec_call:
 			iter->ref.kid = child;
 			iter->ref.next = (ref_t*)vm_ptop();
 			while ( iter->ref.kid != 0 ) {
-				tryFirst = true;
+				try_first = true;
 				goto rec_call;
 				rec_return:
 				iter->ref.kid = iter->ref.kid->next;
@@ -358,44 +358,44 @@ rec_call:
 	*psp = sp;
 }
 
-tree_t *treeIterAdvance( program_t *prg, tree_t ***psp, tree_iter_t *iter )
+tree_t *tree_iter_advance( program_t *prg, tree_t ***psp, tree_iter_t *iter )
 {
 	tree_t **sp = *psp;
-	assert( iter->yieldSize == (vm_ssize() - iter->rootSize) );
+	assert( iter->yield_size == (vm_ssize() - iter->root_size) );
 
 	if ( iter->ref.kid == 0 ) {
 		/* kid_t is zero, start from the root. */
-		iter->ref = iter->rootRef;
-		iterFind( prg, psp, iter, true );
+		iter->ref = iter->root_ref;
+		iter_find( prg, psp, iter, true );
 	}
 	else {
 		/* Have a previous item, continue searching from there. */
-		iterFind( prg, psp, iter, false );
+		iter_find( prg, psp, iter, false );
 	}
 
 	sp = *psp;
-	iter->yieldSize = vm_ssize() - iter->rootSize;
+	iter->yield_size = vm_ssize() - iter->root_size;
 
-	return (iter->ref.kid ? prg->trueVal : prg->falseVal );
+	return (iter->ref.kid ? prg->true_val : prg->false_val );
 }
 
-tree_t *treeIterNextChild( program_t *prg, tree_t ***psp, tree_iter_t *iter )
+tree_t *tree_iter_next_child( program_t *prg, tree_t ***psp, tree_iter_t *iter )
 {
 	tree_t **sp = *psp;
-	assert( iter->yieldSize == (vm_ssize() - iter->rootSize) );
+	assert( iter->yield_size == (vm_ssize() - iter->root_size) );
 	kid_t *kid = 0;
 
 	if ( iter->ref.kid == 0 ) {
 		/* kid_t is zero, start from the first child. */
-		kid_t *child = treeChild( prg, iter->rootRef.kid->tree );
+		kid_t *child = tree_child( prg, iter->root_ref.kid->tree );
 
 		if ( child == 0 )
 			iter->ref.next = 0;
 		else {
 			/* Make a reference to the root. */
 			vm_contiguous( 2 );
-			vm_push_ref( iter->rootRef.next );
-			vm_push_kid( iter->rootRef.kid );
+			vm_push_ref( iter->root_ref.next );
+			vm_push_kid( iter->root_ref.kid );
 			iter->ref.next = (ref_t*)vm_ptop();
 
 			kid = child;
@@ -406,29 +406,29 @@ tree_t *treeIterNextChild( program_t *prg, tree_t ***psp, tree_iter_t *iter )
 		kid = iter->ref.kid->next;
 	}
 
-	if ( iter->searchId != prg->rtd->anyId ) {
+	if ( iter->search_id != prg->rtd->any_id ) {
 		/* Have a previous item, go to the next sibling. */
-		while ( kid != 0 && kid->tree->id != iter->searchId )
+		while ( kid != 0 && kid->tree->id != iter->search_id )
 			kid = kid->next;
 	}
 
 	iter->ref.kid = kid;
-	iter->yieldSize = vm_ssize() - iter->rootSize;
+	iter->yield_size = vm_ssize() - iter->root_size;
 	*psp = sp;
-	return ( iter->ref.kid ? prg->trueVal : prg->falseVal );
+	return ( iter->ref.kid ? prg->true_val : prg->false_val );
 }
 
-tree_t *treeRevIterPrevChild( program_t *prg, tree_t ***psp, rev_tree_iter_t *iter )
+tree_t *tree_rev_iter_prev_child( program_t *prg, tree_t ***psp, rev_tree_iter_t *iter )
 {
 	tree_t **sp = *psp;
-	assert( iter->yieldSize == ( vm_ssize() - iter->rootSize ) );
+	assert( iter->yield_size == ( vm_ssize() - iter->root_size ) );
 
-	if ( iter->kidAtYield != iter->ref.kid ) {
+	if ( iter->kid_at_yield != iter->ref.kid ) {
 		/* Need to reload the kids. */
 		vm_popn( iter->children );
 
 		int c;
-		kid_t *kid = treeChild( prg, iter->rootRef.kid->tree );
+		kid_t *kid = tree_child( prg, iter->root_ref.kid->tree );
 		for ( c = 0; c < iter->children; c++ ) {
 			vm_push_kid( kid );
 			kid = kid->next;
@@ -440,9 +440,9 @@ tree_t *treeRevIterPrevChild( program_t *prg, tree_t ***psp, rev_tree_iter_t *it
 		iter->children -= 1;
 	}
 
-	if ( iter->searchId != prg->rtd->anyId ) {
+	if ( iter->search_id != prg->rtd->any_id ) {
 		/* Have a previous item, go to the next sibling. */
-		while ( iter->children > 0 && ((kid_t*)(vm_top()))->tree->id != iter->searchId ) {
+		while ( iter->children > 0 && ((kid_t*)(vm_top()))->tree->id != iter->search_id ) {
 			iter->children -= 1;
 			vm_pop_ignore();
 		}
@@ -453,29 +453,29 @@ tree_t *treeRevIterPrevChild( program_t *prg, tree_t ***psp, rev_tree_iter_t *it
 		iter->ref.kid = 0;
 	}
 	else {
-		iter->ref.next = &iter->rootRef;
+		iter->ref.next = &iter->root_ref;
 		iter->ref.kid = (kid_t*)vm_top();
 	}
 
 	/* We will use this to detect a split above the iterated tree. */
-	iter->kidAtYield = iter->ref.kid;
+	iter->kid_at_yield = iter->ref.kid;
 
-	iter->yieldSize = vm_ssize() - iter->rootSize;
+	iter->yield_size = vm_ssize() - iter->root_size;
 
 	*psp = sp;
 
-	return (iter->ref.kid ? prg->trueVal : prg->falseVal );
+	return (iter->ref.kid ? prg->true_val : prg->false_val );
 }
 
-void iterFindRepeat( program_t *prg, tree_t ***psp, tree_iter_t *iter, int tryFirst )
+void iter_find_repeat( program_t *prg, tree_t ***psp, tree_iter_t *iter, int try_first )
 {
 	tree_t **sp = *psp;
-	int anyTree = iter->searchId == prg->rtd->anyId;
-	tree_t **top = iter->stackRoot;
+	int any_tree = iter->search_id == prg->rtd->any_id;
+	tree_t **top = iter->stack_root;
 	kid_t *child;
 
 rec_call:
-	if ( tryFirst && ( iter->ref.kid->tree->id == iter->searchId || anyTree ) ) {
+	if ( try_first && ( iter->ref.kid->tree->id == iter->search_id || any_tree ) ) {
 		*psp = sp;
 		return;
 	}
@@ -485,7 +485,7 @@ rec_call:
 		 * root of the iteration, or if does not have any neighbours to the
 		 * right. */
 		if ( top == vm_ptop() || iter->ref.kid->next == 0  ) {
-			child = treeChild( prg, iter->ref.kid->tree );
+			child = tree_child( prg, iter->ref.kid->tree );
 			if ( child != 0 ) {
 				vm_contiguous( 2 );
 				vm_push_ref( iter->ref.next );
@@ -493,7 +493,7 @@ rec_call:
 				iter->ref.kid = child;
 				iter->ref.next = (ref_t*)vm_ptop();
 				while ( iter->ref.kid != 0 ) {
-					tryFirst = true;
+					try_first = true;
 					goto rec_call;
 					rec_return:
 					iter->ref.kid = iter->ref.kid->next;
@@ -511,38 +511,38 @@ rec_call:
 	*psp = sp;
 }
 
-tree_t *treeIterNextRepeat( program_t *prg, tree_t ***psp, tree_iter_t *iter )
+tree_t *tree_iter_next_repeat( program_t *prg, tree_t ***psp, tree_iter_t *iter )
 {
 	tree_t **sp = *psp;
-	assert( iter->yieldSize == ( vm_ssize() - iter->rootSize ) );
+	assert( iter->yield_size == ( vm_ssize() - iter->root_size ) );
 
 	if ( iter->ref.kid == 0 ) {
 		/* kid_t is zero, start from the root. */
-		iter->ref = iter->rootRef;
-		iterFindRepeat( prg, psp, iter, true );
+		iter->ref = iter->root_ref;
+		iter_find_repeat( prg, psp, iter, true );
 	}
 	else {
 		/* Have a previous item, continue searching from there. */
-		iterFindRepeat( prg, psp, iter, false );
+		iter_find_repeat( prg, psp, iter, false );
 	}
 
 	sp = *psp;
-	iter->yieldSize = vm_ssize() - iter->rootSize;
+	iter->yield_size = vm_ssize() - iter->root_size;
 
-	return (iter->ref.kid ? prg->trueVal : prg->falseVal );
+	return (iter->ref.kid ? prg->true_val : prg->false_val );
 }
 
-void iterFindRevRepeat( program_t *prg, tree_t ***psp, tree_iter_t *iter, int tryFirst )
+void iter_find_rev_repeat( program_t *prg, tree_t ***psp, tree_iter_t *iter, int try_first )
 {
 	tree_t **sp = *psp;
-	int anyTree = iter->searchId == prg->rtd->anyId;
-	tree_t **top = iter->stackRoot;
+	int any_tree = iter->search_id == prg->rtd->any_id;
+	tree_t **top = iter->stack_root;
 	kid_t *child;
 
-	if ( tryFirst ) {
+	if ( try_first ) {
 		while ( true ) {
 			if ( top == vm_ptop() || iter->ref.kid->next == 0 ) {
-				child = treeChild( prg, iter->ref.kid->tree );
+				child = tree_child( prg, iter->ref.kid->tree );
 
 				if ( child == 0 )
 					break;
@@ -572,14 +572,14 @@ void iterFindRevRepeat( program_t *prg, tree_t ***psp, tree_iter_t *iter, int tr
 			 * because the chain may have been split, setting it null (to
 			 * prevent repeated walks up). */
 			ref_t *ref = (ref_t*)vm_ptop();
-			iter->ref.kid = treeChild( prg, ref->kid->tree );
+			iter->ref.kid = tree_child( prg, ref->kid->tree );
 		}
 		else {
 			iter->ref.kid = vm_pop_kid();
 			iter->ref.next = vm_pop_ref();
 		}
 first:
-		if ( iter->ref.kid->tree->id == iter->searchId || anyTree ) {
+		if ( iter->ref.kid->tree->id == iter->search_id || any_tree ) {
 			*psp = sp;
 			return;
 		}
@@ -589,25 +589,25 @@ first:
 }
 
 
-tree_t *treeIterPrevRepeat( program_t *prg, tree_t ***psp, tree_iter_t *iter )
+tree_t *tree_iter_prev_repeat( program_t *prg, tree_t ***psp, tree_iter_t *iter )
 {
 	tree_t **sp = *psp;
-	assert( iter->yieldSize == (vm_ssize() - iter->rootSize) );
+	assert( iter->yield_size == (vm_ssize() - iter->root_size) );
 
 	if ( iter->ref.kid == 0 ) {
 		/* kid_t is zero, start from the root. */
-		iter->ref = iter->rootRef;
-		iterFindRevRepeat( prg, psp, iter, true );
+		iter->ref = iter->root_ref;
+		iter_find_rev_repeat( prg, psp, iter, true );
 	}
 	else {
 		/* Have a previous item, continue searching from there. */
-		iterFindRevRepeat( prg, psp, iter, false );
+		iter_find_rev_repeat( prg, psp, iter, false );
 	}
 
 	sp = *psp;
-	iter->yieldSize = vm_ssize() - iter->rootSize;
+	iter->yield_size = vm_ssize() - iter->root_size;
 
-	return (iter->ref.kid ? prg->trueVal : prg->falseVal );
+	return (iter->ref.kid ? prg->true_val : prg->false_val );
 }