large scale symbol renaming in C codecolm-barracuda-v3

using _ conventions for C, camelCase of C++

1 files changed, 465 insertions, 465 deletions

diff --git a/src/tree.c b/src/tree.c
index 33f693f0..3370a793 100644
--- a/src/tree.c
+++ b/src/tree.c
@@ -39,7 +39,7 @@
 
 #define BUFFER_INITIAL_SIZE 4096
 
-kid_t *allocAttrs( program_t *prg, long length )
+kid_t *alloc_attrs( program_t *prg, long length )
 {
 	kid_t *cur = 0;
 	long i;
@@ -51,7 +51,7 @@ kid_t *allocAttrs( program_t *prg, long length )
 	return cur;
 }
 
-void freeAttrs( program_t *prg, kid_t *attrs )
+void free_attrs( program_t *prg, kid_t *attrs )
 {
 	kid_t *cur = attrs;
 	while ( cur != 0 ) {
@@ -61,7 +61,7 @@ void freeAttrs( program_t *prg, kid_t *attrs )
 	}
 }
 
-void freeKidList( program_t *prg, kid_t *kid )
+void free_kid_list( program_t *prg, kid_t *kid )
 {
 	while ( kid != 0 ) {
 		kid_t *next = kid->next;
@@ -149,7 +149,7 @@ int colm_list_last( tree_t *tree )
 	return kid->next == 0;
 }
 
-kid_t *getAttrKid( tree_t *tree, long pos )
+kid_t *get_attr_kid( tree_t *tree, long pos )
 {
 	long i;
 	kid_t *kid = tree->child;
@@ -164,7 +164,7 @@ kid_t *getAttrKid( tree_t *tree, long pos )
 	return kid;
 }
 
-kid_t *kidListConcat( kid_t *list1, kid_t *list2 )
+kid_t *kid_list_concat( kid_t *list1, kid_t *list2 )
 {
 	if ( list1 == 0 )
 		return list2;
@@ -195,72 +195,72 @@ value_t colm_get_pointer_val( tree_t *ptr )
 
 tree_t *colm_construct_term( program_t *prg, word_t id, head_t *tokdata )
 {
-	struct lang_el_info *lelInfo = prg->rtd->lelInfo;
+	struct lang_el_info *lel_info = prg->rtd->lel_info;
 
 	tree_t *tree = tree_allocate( prg );
 	tree->id = id;
 	tree->refs = 0;
 	tree->tokdata = tokdata;
 
-	int objectLength = lelInfo[tree->id].objectLength;
-	tree->child = allocAttrs( prg, objectLength );
+	int object_length = lel_info[tree->id].object_length;
+	tree->child = alloc_attrs( prg, object_length );
 
 	return tree;
 }
 
 
-kid_t *constructKid( program_t *prg, tree_t **bindings, kid_t *prev, long pat );
+kid_t *construct_kid( program_t *prg, tree_t **bindings, kid_t *prev, long pat );
 
-static kid_t *constructIgnoreList( program_t *prg, long ignoreInd )
+static kid_t *construct_ignore_list( program_t *prg, long ignore_ind )
 {
-	struct pat_cons_node *nodes = prg->rtd->patReplNodes;
+	struct pat_cons_node *nodes = prg->rtd->pat_repl_nodes;
 
 	kid_t *first = 0, *last = 0;
-	while ( ignoreInd >= 0 ) {
-		head_t *ignoreData = colm_string_alloc_pointer( prg, nodes[ignoreInd].data,
-				nodes[ignoreInd].length );
+	while ( ignore_ind >= 0 ) {
+		head_t *ignore_data = colm_string_alloc_pointer( prg, nodes[ignore_ind].data,
+				nodes[ignore_ind].length );
 
-		tree_t *ignTree = tree_allocate( prg );
-		ignTree->refs = 1;
-		ignTree->id = nodes[ignoreInd].id;
-		ignTree->tokdata = ignoreData;
+		tree_t *ign_tree = tree_allocate( prg );
+		ign_tree->refs = 1;
+		ign_tree->id = nodes[ignore_ind].id;
+		ign_tree->tokdata = ignore_data;
 
-		kid_t *ignKid = kid_allocate( prg );
-		ignKid->tree = ignTree;
-		ignKid->next = 0;
+		kid_t *ign_kid = kid_allocate( prg );
+		ign_kid->tree = ign_tree;
+		ign_kid->next = 0;
 
 		if ( last == 0 )
-			first = ignKid;
+			first = ign_kid;
 		else
-			last->next = ignKid;
+			last->next = ign_kid;
 
-		ignoreInd = nodes[ignoreInd].next;
-		last = ignKid;
+		ignore_ind = nodes[ignore_ind].next;
+		last = ign_kid;
 	}
 
 	return first;
 }
 
-static kid_t *constructLeftIgnoreList( program_t *prg, long pat )
+static kid_t *construct_left_ignore_list( program_t *prg, long pat )
 {
-	struct pat_cons_node *nodes = prg->rtd->patReplNodes;
-	return constructIgnoreList( prg, nodes[pat].leftIgnore );
+	struct pat_cons_node *nodes = prg->rtd->pat_repl_nodes;
+	return construct_ignore_list( prg, nodes[pat].left_ignore );
 }
 
-static kid_t *constructRightIgnoreList( program_t *prg, long pat )
+static kid_t *construct_right_ignore_list( program_t *prg, long pat )
 {
-	struct pat_cons_node *nodes = prg->rtd->patReplNodes;
-	return constructIgnoreList( prg, nodes[pat].rightIgnore );
+	struct pat_cons_node *nodes = prg->rtd->pat_repl_nodes;
+	return construct_ignore_list( prg, nodes[pat].right_ignore );
 }
 
-static void insLeftIgnore( program_t *prg, tree_t *tree, tree_t *ignoreList )
+static void ins_left_ignore( program_t *prg, tree_t *tree, tree_t *ignore_list )
 {
 	assert( ! (tree->flags & AF_LEFT_IGNORE) );
 
 	/* Allocate. */
 	kid_t *kid = kid_allocate( prg );
-	kid->tree = ignoreList;
-	colm_tree_upref( ignoreList );
+	kid->tree = ignore_list;
+	colm_tree_upref( ignore_list );
 
 	/* Attach it. */
 	kid->next = tree->child;
@@ -269,14 +269,14 @@ static void insLeftIgnore( program_t *prg, tree_t *tree, tree_t *ignoreList )
 	tree->flags |= AF_LEFT_IGNORE;
 }
 
-static void insRightIgnore( program_t *prg, tree_t *tree, tree_t *ignoreList )
+static void ins_right_ignore( program_t *prg, tree_t *tree, tree_t *ignore_list )
 {
 	assert( ! (tree->flags & AF_RIGHT_IGNORE) );
 
 	/* Insert an ignore head in the child list. */
 	kid_t *kid = kid_allocate( prg );
-	kid->tree = ignoreList;
-	colm_tree_upref( ignoreList );
+	kid->tree = ignore_list;
+	colm_tree_upref( ignore_list );
 
 	/* Attach it. */
 	if ( tree->flags & AF_LEFT_IGNORE ) {
@@ -291,57 +291,57 @@ static void insRightIgnore( program_t *prg, tree_t *tree, tree_t *ignoreList )
 	tree->flags |= AF_RIGHT_IGNORE;
 }
 
-tree_t *push_right_ignore( program_t *prg, tree_t *pushTo, tree_t *rightIgnore )
+tree_t *push_right_ignore( program_t *prg, tree_t *push_to, tree_t *right_ignore )
 {
 	/* About to alter the data tree. Split first. */
-	pushTo = splitTree( prg, pushTo );
+	push_to = split_tree( prg, push_to );
 
-	if ( pushTo->flags & AF_RIGHT_IGNORE ) {
+	if ( push_to->flags & AF_RIGHT_IGNORE ) {
 		/* The previous token already has a right ignore. Merge by
 		 * attaching it as a left ignore of the new list. */
-		kid_t *curIgnore = treeRightIgnoreKid( prg, pushTo );
-		insLeftIgnore( prg, rightIgnore, curIgnore->tree );
+		kid_t *cur_ignore = tree_right_ignore_kid( prg, push_to );
+		ins_left_ignore( prg, right_ignore, cur_ignore->tree );
 
 		/* Replace the current ignore. Safe to access refs here because we just
 		 * upreffed it in insLeftIgnore. */
-		curIgnore->tree->refs -= 1;
-		curIgnore->tree = rightIgnore;
-		colm_tree_upref( rightIgnore );
+		cur_ignore->tree->refs -= 1;
+		cur_ignore->tree = right_ignore;
+		colm_tree_upref( right_ignore );
 	}
 	else {
 		/* Attach The ignore list. */
-		insRightIgnore( prg, pushTo, rightIgnore );
+		ins_right_ignore( prg, push_to, right_ignore );
 	}
 
-	return pushTo;
+	return push_to;
 }
 
-tree_t *push_left_ignore( program_t *prg, tree_t *pushTo, tree_t *leftIgnore )
+tree_t *push_left_ignore( program_t *prg, tree_t *push_to, tree_t *left_ignore )
 {
-	pushTo = splitTree( prg, pushTo );
+	push_to = split_tree( prg, push_to );
 
 	/* Attach as left ignore to the token we are sending. */
-	if ( pushTo->flags & AF_LEFT_IGNORE ) {
+	if ( push_to->flags & AF_LEFT_IGNORE ) {
 		/* The token already has a left-ignore. Merge by attaching it as a
 		 * right ignore of the new list. */
-		kid_t *curIgnore = treeLeftIgnoreKid( prg, pushTo );
-		insRightIgnore( prg, leftIgnore, curIgnore->tree );
+		kid_t *cur_ignore = tree_left_ignore_kid( prg, push_to );
+		ins_right_ignore( prg, left_ignore, cur_ignore->tree );
 
 		/* Replace the current ignore. Safe to upref here because we just
 		 * upreffed it in insRightIgnore. */
-		curIgnore->tree->refs -= 1;
-		curIgnore->tree = leftIgnore;
-		colm_tree_upref( leftIgnore );
+		cur_ignore->tree->refs -= 1;
+		cur_ignore->tree = left_ignore;
+		colm_tree_upref( left_ignore );
 	}
 	else {
 		/* Attach the ignore list. */
-		insLeftIgnore( prg, pushTo, leftIgnore );
+		ins_left_ignore( prg, push_to, left_ignore );
 	}
 
-	return pushTo;
+	return push_to;
 }
 
-static void remLeftIgnore( program_t *prg, tree_t **sp, tree_t *tree )
+static void rem_left_ignore( program_t *prg, tree_t **sp, tree_t *tree )
 {
 	assert( tree->flags & AF_LEFT_IGNORE );
 
@@ -353,7 +353,7 @@ static void remLeftIgnore( program_t *prg, tree_t **sp, tree_t *tree )
 	tree->flags &= ~AF_LEFT_IGNORE;
 }
 
-static void remRightIgnore( program_t *prg, tree_t **sp, tree_t *tree )
+static void rem_right_ignore( program_t *prg, tree_t **sp, tree_t *tree )
 {
 	assert( tree->flags & AF_RIGHT_IGNORE );
 
@@ -373,75 +373,75 @@ static void remRightIgnore( program_t *prg, tree_t **sp, tree_t *tree )
 	tree->flags &= ~AF_RIGHT_IGNORE;
 }
 
-tree_t *popRightIgnore( program_t *prg, tree_t **sp, tree_t *popFrom, tree_t **rightIgnore )
+tree_t *pop_right_ignore( program_t *prg, tree_t **sp, tree_t *pop_from, tree_t **right_ignore )
 {
 	/* Modifying the tree we are detaching from. */
-	popFrom = splitTree( prg, popFrom );
+	pop_from = split_tree( prg, pop_from );
 
-	kid_t *riKid = treeRightIgnoreKid( prg, popFrom );
+	kid_t *ri_kid = tree_right_ignore_kid( prg, pop_from );
 
 	/* If the right ignore has a left ignore, then that was the original
 	 * right ignore. */
-	kid_t *li = treeLeftIgnoreKid( prg, riKid->tree );
+	kid_t *li = tree_left_ignore_kid( prg, ri_kid->tree );
 	if ( li != 0 ) {
 		colm_tree_upref( li->tree );
-		remLeftIgnore( prg, sp, riKid->tree );
-		*rightIgnore = riKid->tree;
-		colm_tree_upref( *rightIgnore );
-		riKid->tree = li->tree;
+		rem_left_ignore( prg, sp, ri_kid->tree );
+		*right_ignore = ri_kid->tree;
+		colm_tree_upref( *right_ignore );
+		ri_kid->tree = li->tree;
 	}
 	else  {
-		*rightIgnore = riKid->tree;
-		colm_tree_upref( *rightIgnore );
-		remRightIgnore( prg, sp, popFrom );
+		*right_ignore = ri_kid->tree;
+		colm_tree_upref( *right_ignore );
+		rem_right_ignore( prg, sp, pop_from );
 	}
 
-	return popFrom;
+	return pop_from;
 }
 
-tree_t *popLeftIgnore( program_t *prg, tree_t **sp, tree_t *popFrom, tree_t **leftIgnore )
+tree_t *pop_left_ignore( program_t *prg, tree_t **sp, tree_t *pop_from, tree_t **left_ignore )
 {
 	/* Modifying, make the write safe. */
-	popFrom = splitTree( prg, popFrom );
+	pop_from = split_tree( prg, pop_from );
 
-	kid_t *liKid = treeLeftIgnoreKid( prg, popFrom );
+	kid_t *li_kid = tree_left_ignore_kid( prg, pop_from );
 
 	/* If the left ignore has a right ignore, then that was the original
 	 * left ignore. */
-	kid_t *ri = treeRightIgnoreKid( prg, liKid->tree );
+	kid_t *ri = tree_right_ignore_kid( prg, li_kid->tree );
 	if ( ri != 0 ) {
 		colm_tree_upref( ri->tree );
-		remRightIgnore( prg, sp, liKid->tree );
-		*leftIgnore = liKid->tree;
-		colm_tree_upref( *leftIgnore );
-		liKid->tree = ri->tree;
+		rem_right_ignore( prg, sp, li_kid->tree );
+		*left_ignore = li_kid->tree;
+		colm_tree_upref( *left_ignore );
+		li_kid->tree = ri->tree;
 	}
 	else {
-		*leftIgnore = liKid->tree;
-		colm_tree_upref( *leftIgnore );
-		remLeftIgnore( prg, sp, popFrom );
+		*left_ignore = li_kid->tree;
+		colm_tree_upref( *left_ignore );
+		rem_left_ignore( prg, sp, pop_from );
 	}
 
-	return popFrom;
+	return pop_from;
 }
 
-tree_t *colm_construct_object( program_t *prg, kid_t *kid, tree_t **bindings, long langElId )
+tree_t *colm_construct_object( program_t *prg, kid_t *kid, tree_t **bindings, long lang_el_id )
 {
-	struct lang_el_info *lelInfo = prg->rtd->lelInfo;
+	struct lang_el_info *lel_info = prg->rtd->lel_info;
 	tree_t *tree = 0;
 
 	tree = tree_allocate( prg );
-	tree->id = langElId;
+	tree->id = lang_el_id;
 	tree->refs = 1;
 	tree->tokdata = 0;
 	tree->prod_num = 0;
 
-	int objectLength = lelInfo[tree->id].objectLength;
+	int object_length = lel_info[tree->id].object_length;
 
-	kid_t *attrs = allocAttrs( prg, objectLength );
+	kid_t *attrs = alloc_attrs( prg, object_length );
 	kid_t *child = 0;
 
-	tree->child = kidListConcat( attrs, child );
+	tree->child = kid_list_concat( attrs, child );
 
 	return tree;
 }
@@ -450,36 +450,36 @@ tree_t *colm_construct_object( program_t *prg, kid_t *kid, tree_t **bindings, lo
  * return a zero-ref tree. */
 tree_t *colm_construct_tree( program_t *prg, kid_t *kid, tree_t **bindings, long pat )
 {
-	struct pat_cons_node *nodes = prg->rtd->patReplNodes;
-	struct lang_el_info *lelInfo = prg->rtd->lelInfo;
+	struct pat_cons_node *nodes = prg->rtd->pat_repl_nodes;
+	struct lang_el_info *lel_info = prg->rtd->lel_info;
 	tree_t *tree = 0;
 
-	if ( nodes[pat].bindId > 0 ) {
+	if ( nodes[pat].bind_id > 0 ) {
 		/* All bindings have been uprefed. */
-		tree = bindings[nodes[pat].bindId];
+		tree = bindings[nodes[pat].bind_id];
 
-		long ignore = nodes[pat].leftIgnore;
-		tree_t *leftIgnore = 0;
+		long ignore = nodes[pat].left_ignore;
+		tree_t *left_ignore = 0;
 		if ( ignore >= 0 ) {
-			kid_t *ignore = constructLeftIgnoreList( prg, pat );
+			kid_t *ignore = construct_left_ignore_list( prg, pat );
 
-			leftIgnore = tree_allocate( prg );
-			leftIgnore->id = LEL_ID_IGNORE;
-			leftIgnore->child = ignore;
+			left_ignore = tree_allocate( prg );
+			left_ignore->id = LEL_ID_IGNORE;
+			left_ignore->child = ignore;
 
-			tree = push_left_ignore( prg, tree, leftIgnore );
+			tree = push_left_ignore( prg, tree, left_ignore );
 		}
 
-		ignore = nodes[pat].rightIgnore;
-		tree_t *rightIgnore = 0;
+		ignore = nodes[pat].right_ignore;
+		tree_t *right_ignore = 0;
 		if ( ignore >= 0 ) {
-			kid_t *ignore = constructRightIgnoreList( prg, pat );
+			kid_t *ignore = construct_right_ignore_list( prg, pat );
 
-			rightIgnore = tree_allocate( prg );
-			rightIgnore->id = LEL_ID_IGNORE;
-			rightIgnore->child = ignore;
+			right_ignore = tree_allocate( prg );
+			right_ignore->id = LEL_ID_IGNORE;
+			right_ignore->child = ignore;
 
-			tree = push_right_ignore( prg, tree, rightIgnore );
+			tree = push_right_ignore( prg, tree, right_ignore );
 		}
 	}
 	else {
@@ -489,51 +489,51 @@ tree_t *colm_construct_tree( program_t *prg, kid_t *kid, tree_t **bindings, long
 		tree->tokdata = nodes[pat].length == 0 ? 0 :
 				colm_string_alloc_pointer( prg, 
 				nodes[pat].data, nodes[pat].length );
-		tree->prod_num = nodes[pat].prodNum;
+		tree->prod_num = nodes[pat].prod_num;
 
-		int objectLength = lelInfo[tree->id].objectLength;
+		int object_length = lel_info[tree->id].object_length;
 
-		kid_t *attrs = allocAttrs( prg, objectLength );
-		kid_t *child = constructKid( prg, bindings,
+		kid_t *attrs = alloc_attrs( prg, object_length );
+		kid_t *child = construct_kid( prg, bindings,
 				0, nodes[pat].child );
 
-		tree->child = kidListConcat( attrs, child );
+		tree->child = kid_list_concat( attrs, child );
 
 		/* Right first, then left. */
-		kid_t *ignore = constructRightIgnoreList( prg, pat );
+		kid_t *ignore = construct_right_ignore_list( prg, pat );
 		if ( ignore != 0 ) {
-			tree_t *ignoreList = tree_allocate( prg );
-			ignoreList->id = LEL_ID_IGNORE;
-			ignoreList->refs = 1;
-			ignoreList->child = ignore;
+			tree_t *ignore_list = tree_allocate( prg );
+			ignore_list->id = LEL_ID_IGNORE;
+			ignore_list->refs = 1;
+			ignore_list->child = ignore;
 
-			kid_t *ignoreHead = kid_allocate( prg );
-			ignoreHead->tree = ignoreList;
-			ignoreHead->next = tree->child;
-			tree->child = ignoreHead;
+			kid_t *ignore_head = kid_allocate( prg );
+			ignore_head->tree = ignore_list;
+			ignore_head->next = tree->child;
+			tree->child = ignore_head;
 
 			tree->flags |= AF_RIGHT_IGNORE;
 		}
 
-		ignore = constructLeftIgnoreList( prg, pat );
+		ignore = construct_left_ignore_list( prg, pat );
 		if ( ignore != 0 ) {
-			tree_t *ignoreList = tree_allocate( prg );
-			ignoreList->id = LEL_ID_IGNORE;
-			ignoreList->refs = 1;
-			ignoreList->child = ignore;
+			tree_t *ignore_list = tree_allocate( prg );
+			ignore_list->id = LEL_ID_IGNORE;
+			ignore_list->refs = 1;
+			ignore_list->child = ignore;
 
-			kid_t *ignoreHead = kid_allocate( prg );
-			ignoreHead->tree = ignoreList;
-			ignoreHead->next = tree->child;
-			tree->child = ignoreHead;
+			kid_t *ignore_head = kid_allocate( prg );
+			ignore_head->tree = ignore_list;
+			ignore_head->next = tree->child;
+			tree->child = ignore_head;
 
 			tree->flags |= AF_LEFT_IGNORE;
 		}
 
 		int i;
-		for ( i = 0; i < lelInfo[tree->id].numCaptureAttr; i++ ) {
+		for ( i = 0; i < lel_info[tree->id].num_capture_attr; i++ ) {
 			long ci = pat+1+i;
-			CaptureAttr *ca = prg->rtd->captureAttr + lelInfo[tree->id].captureAttr + i;
+			CaptureAttr *ca = prg->rtd->capture_attr + lel_info[tree->id].capture_attr + i;
 			tree_t *attr = tree_allocate( prg );
 			attr->id = nodes[ci].id;
 			attr->refs = 1;
@@ -548,9 +548,9 @@ tree_t *colm_construct_tree( program_t *prg, kid_t *kid, tree_t **bindings, long
 	return tree;
 }
 
-kid_t *constructKid( program_t *prg, tree_t **bindings, kid_t *prev, long pat )
+kid_t *construct_kid( program_t *prg, tree_t **bindings, kid_t *prev, long pat )
 {
-	struct pat_cons_node *nodes = prg->rtd->patReplNodes;
+	struct pat_cons_node *nodes = prg->rtd->pat_repl_nodes;
 	kid_t *kid = 0;
 
 	if ( pat != -1 ) {
@@ -558,7 +558,7 @@ kid_t *constructKid( program_t *prg, tree_t **bindings, kid_t *prev, long pat )
 		kid->tree = colm_construct_tree( prg, kid, bindings, pat );
 
 		/* Recurse down next. */
-		kid_t *next = constructKid( prg, bindings,
+		kid_t *next = construct_kid( prg, bindings,
 				kid, nodes[pat].next );
 
 		kid->next = next;
@@ -569,26 +569,26 @@ kid_t *constructKid( program_t *prg, tree_t **bindings, kid_t *prev, long pat )
 
 tree_t *colm_construct_token( program_t *prg, tree_t **args, long nargs )
 {
-	value_t idInt = (value_t)args[0];
-	str_t *textStr = (str_t*)args[1];
+	value_t id_int = (value_t)args[0];
+	str_t *text_str = (str_t*)args[1];
 
-	long id = (long)idInt;
-	head_t *tokdata = stringCopy( prg, textStr->value );
+	long id = (long)id_int;
+	head_t *tokdata = string_copy( prg, text_str->value );
 
-	struct lang_el_info *lelInfo = prg->rtd->lelInfo;
+	struct lang_el_info *lel_info = prg->rtd->lel_info;
 	tree_t *tree;
 
-	if ( lelInfo[id].ignore ) {
+	if ( lel_info[id].ignore ) {
 		tree = tree_allocate( prg );
 		tree->refs = 1;
 		tree->id = id;
 		tree->tokdata = tokdata;
 	}
 	else {
-		long objectLength = lelInfo[id].objectLength;
-		assert( nargs-2 <= objectLength );
+		long object_length = lel_info[id].object_length;
+		assert( nargs-2 <= object_length );
 
-		kid_t *attrs = allocAttrs( prg, objectLength );
+		kid_t *attrs = alloc_attrs( prg, object_length );
 
 		tree = tree_allocate( prg );
 		tree->id = id;
@@ -606,25 +606,25 @@ tree_t *colm_construct_token( program_t *prg, tree_t **args, long nargs )
 	return tree;
 }
 
-tree_t *castTree( program_t *prg, int langElId, tree_t *tree )
+tree_t *cast_tree( program_t *prg, int lang_el_id, tree_t *tree )
 {
-	struct lang_el_info *lelInfo = prg->rtd->lelInfo;
+	struct lang_el_info *lel_info = prg->rtd->lel_info;
 
 	/* Need to keep a lookout for next down. If 
 	 * copying it, return the copy. */
-	tree_t *newTree = tree_allocate( prg );
+	tree_t *new_tree = tree_allocate( prg );
 
-	newTree->id = langElId;
-	newTree->tokdata = stringCopy( prg, tree->tokdata );
+	new_tree->id = lang_el_id;
+	new_tree->tokdata = string_copy( prg, tree->tokdata );
 
 	/* Invalidate the production number. */
-	newTree->prod_num = -1;
+	new_tree->prod_num = -1;
 
 	/* Copy the child list. Start with ignores, then the list. */
 	kid_t *child = tree->child, *last = 0;
 
 	/* Flags we are interested in. */
-	newTree->flags |= tree->flags & ( AF_LEFT_IGNORE | AF_RIGHT_IGNORE );
+	new_tree->flags |= tree->flags & ( AF_LEFT_IGNORE | AF_RIGHT_IGNORE );
 
 	int ignores = 0;
 	if ( tree->flags & AF_LEFT_IGNORE )
@@ -634,78 +634,78 @@ tree_t *castTree( program_t *prg, int langElId, tree_t *tree )
 
 	/* Igores. */
 	while ( ignores-- > 0 ) {
-		kid_t *newKid = kid_allocate( prg );
+		kid_t *new_kid = kid_allocate( prg );
 
-		newKid->tree = child->tree;
-		newKid->next = 0;
-		newKid->tree->refs += 1;
+		new_kid->tree = child->tree;
+		new_kid->next = 0;
+		new_kid->tree->refs += 1;
 
 		/* Store the first child. */
 		if ( last == 0 )
-			newTree->child = newKid;
+			new_tree->child = new_kid;
 		else
-			last->next = newKid;
+			last->next = new_kid;
 
 		child = child->next;
-		last = newKid;
+		last = new_kid;
 	}
 
 	/* Skip over the source's attributes. */
-	int objectLength = lelInfo[tree->id].objectLength;
-	while ( objectLength-- > 0 )
+	int object_length = lel_info[tree->id].object_length;
+	while ( object_length-- > 0 )
 		child = child->next;
 
 	/* Allocate the target type's kids. */
-	objectLength = lelInfo[langElId].objectLength;
-	while ( objectLength-- > 0 ) {
-		kid_t *newKid = kid_allocate( prg );
+	object_length = lel_info[lang_el_id].object_length;
+	while ( object_length-- > 0 ) {
+		kid_t *new_kid = kid_allocate( prg );
 
-		newKid->tree = 0;
-		newKid->next = 0;
+		new_kid->tree = 0;
+		new_kid->next = 0;
 
 		/* Store the first child. */
 		if ( last == 0 )
-			newTree->child = newKid;
+			new_tree->child = new_kid;
 		else
-			last->next = newKid;
+			last->next = new_kid;
 
-		last = newKid;
+		last = new_kid;
 	}
 	
 	/* Copy the source's children. */
 	while ( child != 0 ) {
-		kid_t *newKid = kid_allocate( prg );
+		kid_t *new_kid = kid_allocate( prg );
 
-		newKid->tree = child->tree;
-		newKid->next = 0;
-		newKid->tree->refs += 1;
+		new_kid->tree = child->tree;
+		new_kid->next = 0;
+		new_kid->tree->refs += 1;
 
 		/* Store the first child. */
 		if ( last == 0 )
-			newTree->child = newKid;
+			new_tree->child = new_kid;
 		else
-			last->next = newKid;
+			last->next = new_kid;
 
 		child = child->next;
-		last = newKid;
+		last = new_kid;
 	}
 	
-	return newTree;
+	return new_tree;
 }
 
-tree_t *makeTree( program_t *prg, tree_t **args, long nargs )
+tree_t *make_tree( program_t *prg, tree_t **args, long nargs )
 {
-	value_t idInt = (value_t)args[0];
+	value_t id_int = (value_t)args[0];
 
-	long id = (long)idInt;
-	struct lang_el_info *lelInfo = prg->rtd->lelInfo;
+	long id = (long)id_int;
+	struct lang_el_info *lel_info = prg->rtd->lel_info;
 
 	tree_t *tree = tree_allocate( prg );
 	tree->id = id;
 	tree->refs = 1;
 
-	long objectLength = lelInfo[id].objectLength;
-	kid_t *attrs = allocAttrs( prg, objectLength );
+	long object_length = lel_info[id].object_length;
+	kid_t *attrs = alloc_attrs( prg, object_length );
 
 	kid_t *last = 0, *child = 0;
 	for ( id = 1; id < nargs; id++ ) {
@@ -721,81 +721,81 @@ tree_t *makeTree( program_t *prg, tree_t **args, long nargs )
 		last = kid;
 	}
 
-	tree->child = kidListConcat( attrs, child );
+	tree->child = kid_list_concat( attrs, child );
 
 	return tree;
 }
 
-int testFalse( program_t *prg, tree_t *tree )
+int test_false( program_t *prg, tree_t *tree )
 {
 	int flse = ( 
 		tree == 0 ||
-		tree == prg->falseVal 
+		tree == prg->false_val 
 	);
 	return flse;
 }
 
-kid_t *copyIgnoreList( program_t *prg, kid_t *ignoreHeader )
+kid_t *copy_ignore_list( program_t *prg, kid_t *ignore_header )
 {
-	kid_t *newHeader = kid_allocate( prg );
-	kid_t *last = 0, *ic = (kid_t*)ignoreHeader->tree;
+	kid_t *new_header = kid_allocate( prg );
+	kid_t *last = 0, *ic = (kid_t*)ignore_header->tree;
 	while ( ic != 0 ) {
-		kid_t *newIc = kid_allocate( prg );
+		kid_t *new_ic = kid_allocate( prg );
 
-		newIc->tree = ic->tree;
-		newIc->tree->refs += 1;
+		new_ic->tree = ic->tree;
+		new_ic->tree->refs += 1;
 
 		/* List pointers. */
 		if ( last == 0 )
-			newHeader->tree = (tree_t*)newIc;
+			new_header->tree = (tree_t*)new_ic;
 		else
-			last->next = newIc;
+			last->next = new_ic;
 
 		ic = ic->next;
-		last = newIc;
+		last = new_ic;
 	}
-	return newHeader;
+	return new_header;
 }
 
-kid_t *copyKidList( program_t *prg, kid_t *kidList )
+kid_t *copy_kid_list( program_t *prg, kid_t *kid_list )
 {
-	kid_t *newList = 0, *last = 0, *ic = kidList;
+	kid_t *new_list = 0, *last = 0, *ic = kid_list;
 
 	while ( ic != 0 ) {
-		kid_t *newIc = kid_allocate( prg );
+		kid_t *new_ic = kid_allocate( prg );
 
-		newIc->tree = ic->tree;
-		colm_tree_upref( newIc->tree );
+		new_ic->tree = ic->tree;
+		colm_tree_upref( new_ic->tree );
 
 		/* List pointers. */
 		if ( last == 0 )
-			newList = newIc;
+			new_list = new_ic;
 		else
-			last->next = newIc;
+			last->next = new_ic;
 
 		ic = ic->next;
-		last = newIc;
+		last = new_ic;
 	}
-	return newList;
+	return new_list;
 }
 
 /* New tree has zero ref. */
-tree_t *copyRealTree( program_t *prg, tree_t *tree, kid_t *oldNextDown, kid_t **newNextDown )
+tree_t *copy_real_tree( program_t *prg, tree_t *tree, kid_t *old_next_down, kid_t **new_next_down )
 {
 	/* Need to keep a lookout for next down. If 
 	 * copying it, return the copy. */
-	tree_t *newTree = tree_allocate( prg );
+	tree_t *new_tree = tree_allocate( prg );
 
-	newTree->id = tree->id;
-	newTree->tokdata = stringCopy( prg, tree->tokdata );
-	newTree->prod_num = tree->prod_num;
+	new_tree->id = tree->id;
+	new_tree->tokdata = string_copy( prg, tree->tokdata );
+	new_tree->prod_num = tree->prod_num;
 
 	/* Copy the child list. Start with ignores, then the list. */
 	kid_t *child = tree->child, *last = 0;
 
 	/* Left ignores. */
 	if ( tree->flags & AF_LEFT_IGNORE ) {
-		newTree->flags |= AF_LEFT_IGNORE;
+		new_tree->flags |= AF_LEFT_IGNORE;
 //		kid_t *newHeader = copyIgnoreList( prg, child );
 //
 //		/* Always the head. */
@@ -807,7 +807,7 @@ tree_t *copyRealTree( program_t *prg, tree_t *tree, kid_t *oldNextDown, kid_t **
 
 	/* Right ignores. */
 	if ( tree->flags & AF_RIGHT_IGNORE ) {
-		newTree->flags |= AF_RIGHT_IGNORE;
+		new_tree->flags |= AF_RIGHT_IGNORE;
 //		kid_t *newHeader = copyIgnoreList( prg, child );
 //		if ( last == 0 )
 //			newTree->child = newHeader;
@@ -819,34 +819,34 @@ tree_t *copyRealTree( program_t *prg, tree_t *tree, kid_t *oldNextDown, kid_t **
 
 	/* Attributes and children. */
 	while ( child != 0 ) {
-		kid_t *newKid = kid_allocate( prg );
+		kid_t *new_kid = kid_allocate( prg );
 
 		/* Watch out for next down. */
-		if ( child == oldNextDown )
-			*newNextDown = newKid;
+		if ( child == old_next_down )
+			*new_next_down = new_kid;
 
-		newKid->tree = child->tree;
-		newKid->next = 0;
+		new_kid->tree = child->tree;
+		new_kid->next = 0;
 
 		/* May be an attribute. */
-		if ( newKid->tree != 0 )
-			newKid->tree->refs += 1;
+		if ( new_kid->tree != 0 )
+			new_kid->tree->refs += 1;
 
 		/* Store the first child. */
 		if ( last == 0 )
-			newTree->child = newKid;
+			new_tree->child = new_kid;
 		else
-			last->next = newKid;
+			last->next = new_kid;
 
 		child = child->next;
-		last = newKid;
+		last = new_kid;
 	}
 	
-	return newTree;
+	return new_tree;
 }
 
 
-tree_t *colm_copy_tree( program_t *prg, tree_t *tree, kid_t *oldNextDown, kid_t **newNextDown )
+tree_t *colm_copy_tree( program_t *prg, tree_t *tree, kid_t *old_next_down, kid_t **new_next_down )
 {
 //	struct lang_el_info *lelInfo = prg->rtd->lelInfo;
 //	long genericId = lelInfo[tree->id].genericId;
@@ -863,28 +863,28 @@ tree_t *colm_copy_tree( program_t *prg, tree_t *tree, kid_t *oldNextDown, kid_t
 //	else if ( tree->id == LEL_ID_STREAM )
 //		assert(false);
 	else {
-		tree = copyRealTree( prg, tree, oldNextDown, newNextDown );
+		tree = copy_real_tree( prg, tree, old_next_down, new_next_down );
 	}
 
 	assert( tree->refs == 0 );
 	return tree;
 }
 
-tree_t *splitTree( program_t *prg, tree_t *tree )
+tree_t *split_tree( program_t *prg, tree_t *tree )
 {
 	if ( tree != 0 ) {
 		assert( tree->refs >= 1 );
 
 		if ( tree->refs > 1 ) {
-			kid_t *oldNextDown = 0, *newNextDown = 0;
-			tree_t *newTree = colm_copy_tree( prg, tree, oldNextDown, &newNextDown );
-			colm_tree_upref( newTree );
+			kid_t *old_next_down = 0, *new_next_down = 0;
+			tree_t *new_tree = colm_copy_tree( prg, tree, old_next_down, &new_next_down );
+			colm_tree_upref( new_tree );
 
 			/* Downref the original. Don't need to consider freeing because
 			 * refs were > 1. */
 			tree->refs -= 1;
 
-			tree = newTree;
+			tree = new_tree;
 		}
 
 		assert( tree->refs == 1 );
@@ -894,7 +894,7 @@ tree_t *splitTree( program_t *prg, tree_t *tree )
 
 /* We can't make recursive calls here since the tree we are freeing may be
  * very large. Need the VM stack. */
-void treeFreeRec( program_t *prg, tree_t **sp, tree_t *tree )
+void tree_free_rec( program_t *prg, tree_t **sp, tree_t *tree )
 {
 	tree_t **top = vm_ptop();
 //	struct lang_el_info *lelInfo;
@@ -913,13 +913,13 @@ free_tree:
 		break;
 	case LEL_ID_STR: {
 		str_t *str = (str_t*) tree;
-		stringFree( prg, str->value );
+		string_free( prg, str->value );
 		tree_free( prg, tree );
 		break;
 	}
 	default: { 
 		if ( tree->id != LEL_ID_IGNORE )
-			stringFree( prg, tree->tokdata );
+			string_free( prg, tree->tokdata );
 
 		/* Attributes and grammar-based children. */
 		kid_t *child = tree->child;
@@ -958,13 +958,13 @@ void colm_tree_downref( program_t *prg, tree_t **sp, tree_t *tree )
 		assert( tree->refs > 0 );
 		tree->refs -= 1;
 		if ( tree->refs == 0 )
-			treeFreeRec( prg, sp, tree );
+			tree_free_rec( prg, sp, tree );
 	}
 }
 
 /* We can't make recursive calls here since the tree we are freeing may be
  * very large. Need the VM stack. */
-void objectFreeRec( program_t *prg, tree_t **sp, tree_t *tree )
+void object_free_rec( program_t *prg, tree_t **sp, tree_t *tree )
 {
 	tree_t **top = vm_ptop();
 //	struct lang_el_info *lelInfo;
@@ -976,7 +976,7 @@ free_tree:
 	switch ( tree->id ) {
 	case LEL_ID_STR: {
 		str_t *str = (str_t*) tree;
-		stringFree( prg, str->value );
+		string_free( prg, str->value );
 		tree_free( prg, tree );
 		break;
 	}
@@ -993,7 +993,7 @@ free_tree:
 //	}
 	default: { 
 		if ( tree->id != LEL_ID_IGNORE )
-			stringFree( prg, tree->tokdata );
+			string_free( prg, tree->tokdata );
 
 		/* Attributes and grammar-based children. */
 		kid_t *child = tree->child;
@@ -1020,20 +1020,20 @@ free_tree:
 	}
 }
 
-void objectDownref( program_t *prg, tree_t **sp, tree_t *tree )
+void object_downref( program_t *prg, tree_t **sp, tree_t *tree )
 {
 	if ( tree != 0 ) {
 		assert( tree->refs > 0 );
 		tree->refs -= 1;
 		if ( tree->refs == 0 )
-			objectFreeRec( prg, sp, tree );
+			object_free_rec( prg, sp, tree );
 	}
 }
 
 /* Find the first child of a tree. */
-kid_t *treeChild( program_t *prg, const tree_t *tree )
+kid_t *tree_child( program_t *prg, const tree_t *tree )
 {
-	struct lang_el_info *lelInfo = prg->rtd->lelInfo;
+	struct lang_el_info *lel_info = prg->rtd->lel_info;
 	kid_t *kid = tree->child;
 
 	if ( tree->flags & AF_LEFT_IGNORE )
@@ -1042,18 +1042,18 @@ kid_t *treeChild( program_t *prg, const tree_t *tree )
 		kid = kid->next;
 
 	/* Skip over attributes. */
-	long objectLength = lelInfo[tree->id].objectLength;
+	long object_length = lel_info[tree->id].object_length;
 	long a;
-	for ( a = 0; a < objectLength; a++ )
+	for ( a = 0; a < object_length; a++ )
 		kid = kid->next;
 
 	return kid;
 }
 
 /* Detach at the first real child of a tree. */
-kid_t *treeExtractChild( program_t *prg, tree_t *tree )
+kid_t *tree_extract_child( program_t *prg, tree_t *tree )
 {
-	struct lang_el_info *lelInfo = prg->rtd->lelInfo;
+	struct lang_el_info *lel_info = prg->rtd->lel_info;
 	kid_t *kid = tree->child, *last = 0;
 
 	if ( tree->flags & AF_LEFT_IGNORE )
@@ -1062,8 +1062,8 @@ kid_t *treeExtractChild( program_t *prg, tree_t *tree )
 		kid = kid->next;
 
 	/* Skip over attributes. */
-	long a, objectLength = lelInfo[tree->id].objectLength;
-	for ( a = 0; a < objectLength; a++ ) {
+	long a, object_length = lel_info[tree->id].object_length;
+	for ( a = 0; a < object_length; a++ ) {
 		last = kid;
 		kid = kid->next;
 	}
@@ -1078,7 +1078,7 @@ kid_t *treeExtractChild( program_t *prg, tree_t *tree )
 
 
 /* Find the first child of a tree. */
-kid_t *treeAttr( program_t *prg, const tree_t *tree )
+kid_t *tree_attr( program_t *prg, const tree_t *tree )
 {
 	kid_t *kid = tree->child;
 
@@ -1090,14 +1090,14 @@ kid_t *treeAttr( program_t *prg, const tree_t *tree )
 	return kid;
 }
 
-tree_t *treeLeftIgnore( program_t *prg, tree_t *tree )
+tree_t *tree_left_ignore( program_t *prg, tree_t *tree )
 {
 	if ( tree->flags & AF_LEFT_IGNORE )
 		return tree->child->tree;
 	return 0;
 }
 
-tree_t *treeRightIgnore( program_t *prg, tree_t *tree )
+tree_t *tree_right_ignore( program_t *prg, tree_t *tree )
 {
 	if ( tree->flags & AF_RIGHT_IGNORE ) {
 		if ( tree->flags & AF_LEFT_IGNORE )
@@ -1108,14 +1108,14 @@ tree_t *treeRightIgnore( program_t *prg, tree_t *tree )
 	return 0;
 }
 
-kid_t *treeLeftIgnoreKid( program_t *prg, tree_t *tree )
+kid_t *tree_left_ignore_kid( program_t *prg, tree_t *tree )
 {
 	if ( tree->flags & AF_LEFT_IGNORE )
 		return tree->child;
 	return 0;
 }
 
-kid_t *treeRightIgnoreKid( program_t *prg, tree_t *tree )
+kid_t *tree_right_ignore_kid( program_t *prg, tree_t *tree )
 {
 	if ( tree->flags & AF_RIGHT_IGNORE ) {
 		if ( tree->flags & AF_LEFT_IGNORE )
@@ -1126,15 +1126,15 @@ kid_t *treeRightIgnoreKid( program_t *prg, tree_t *tree )
 	return 0;
 }
 
-void refSetValue( program_t *prg, tree_t **sp, ref_t *ref, tree_t *v )
+void ref_set_value( program_t *prg, tree_t **sp, ref_t *ref, tree_t *v )
 {
 	colm_tree_downref( prg, sp, ref->kid->tree );
 	ref->kid->tree = v;
 }
 
-tree_t *getRhsEl( program_t *prg, tree_t *lhs, long position )
+tree_t *get_rhs_el( program_t *prg, tree_t *lhs, long position )
 {
-	kid_t *pos = treeChild( prg, lhs );
+	kid_t *pos = tree_child( prg, lhs );
 	while ( position > 0 ) {
 		pos = pos->next;
 		position -= 1;
@@ -1142,9 +1142,9 @@ tree_t *getRhsEl( program_t *prg, tree_t *lhs, long position )
 	return pos->tree;
 }
 
-kid_t *getRhsElKid( program_t *prg, tree_t *lhs, long position )
+kid_t *get_rhs_el_kid( program_t *prg, tree_t *lhs, long position )
 {
-	kid_t *pos = treeChild( prg, lhs );
+	kid_t *pos = tree_child( prg, lhs );
 	while ( position > 0 ) {
 		pos = pos->next;
 		position -= 1;
@@ -1158,9 +1158,9 @@ tree_t *colm_get_rhs_val( program_t *prg, tree_t *tree, int *a )
 	int i, len = a[0];
 	for ( i = 0; i < len; i++ ) {
 		int prod_num = a[1 + i * 2];
-		int childNum = a[1 + i * 2 + 1];
+		int child_num = a[1 + i * 2 + 1];
 		if ( tree->prod_num == prod_num )
-			return getRhsEl( prg, tree, childNum );
+			return get_rhs_el( prg, tree, child_num );
 	}
 	return 0;
 }
@@ -1178,24 +1178,24 @@ tree_t *colm_tree_get_field( tree_t *tree, word_t field )
 	return colm_get_attr( tree, field );
 }
 
-kid_t *getFieldKid( tree_t *tree, word_t field )
+kid_t *get_field_kid( tree_t *tree, word_t field )
 {
-	return getAttrKid( tree, field );
+	return get_attr_kid( tree, field );
 }
 
-tree_t *getFieldSplit( program_t *prg, tree_t *tree, word_t field )
+tree_t *get_field_split( program_t *prg, tree_t *tree, word_t field )
 {
 	tree_t *val = colm_get_attr( tree, field );
-	tree_t *split = splitTree( prg, val );
+	tree_t *split = split_tree( prg, val );
 	colm_tree_set_attr( tree, field, split );
 	return split;
 }
 
 /* This must traverse in the same order that the bindId assignments are done
  * in. */
-int matchPattern( tree_t **bindings, program_t *prg, long pat, kid_t *kid, int checkNext )
+int match_pattern( tree_t **bindings, program_t *prg, long pat, kid_t *kid, int check_next )
 {
-	struct pat_cons_node *nodes = prg->rtd->patReplNodes;
+	struct pat_cons_node *nodes = prg->rtd->pat_repl_nodes;
 
 	/* match node, recurse on children. */
 	if ( pat != -1 && kid != 0 ) {
@@ -1204,35 +1204,35 @@ int matchPattern( tree_t **bindings, program_t *prg, long pat, kid_t *kid, int c
 			 * the data against the token data. */
 			if ( nodes[pat].data != 0 ) {
 				/* Check the length of token text. */
-				if ( nodes[pat].length != stringLength( kid->tree->tokdata ) )
+				if ( nodes[pat].length != string_length( kid->tree->tokdata ) )
 					return false;
 
 				/* Check the token text data. */
 				if ( nodes[pat].length > 0 && memcmp( nodes[pat].data, 
-						stringData( kid->tree->tokdata ), nodes[pat].length ) != 0 )
+						string_data( kid->tree->tokdata ), nodes[pat].length ) != 0 )
 					return false;
 			}
 
 			/* No failure, all okay. */
-			if ( nodes[pat].bindId > 0 ) {
-				bindings[nodes[pat].bindId] = kid->tree;
+			if ( nodes[pat].bind_id > 0 ) {
+				bindings[nodes[pat].bind_id] = kid->tree;
 			}
 
 			/* If we didn't match a terminal duplicate of a nonterm then check
 			 * down the children. */
 			if ( !nodes[pat].stop ) {
 				/* Check for failure down child branch. */
-				int childCheck = matchPattern( bindings, prg, 
-						nodes[pat].child, treeChild( prg, kid->tree ), true );
-				if ( ! childCheck )
+				int child_check = match_pattern( bindings, prg, 
+						nodes[pat].child, tree_child( prg, kid->tree ), true );
+				if ( ! child_check )
 					return false;
 			}
 
 			/* If checking next, then look for failure there. */
-			if ( checkNext ) {
-				int nextCheck = matchPattern( bindings, prg, 
+			if ( check_next ) {
+				int next_check = match_pattern( bindings, prg, 
 						nodes[pat].next, kid->next, true );
-				if ( ! nextCheck )
+				if ( ! next_check )
 					return false;
 			}
 
@@ -1270,7 +1270,7 @@ long colm_cmp_tree( program_t *prg, const tree_t *tree1, const tree_t *tree2 )
 			return 1;
 	}
 	else if ( tree1->id == LEL_ID_STR ) {
-		cmpres = cmpString( ((str_t*)tree1)->value, ((str_t*)tree2)->value );
+		cmpres = cmp_string( ((str_t*)tree1)->value, ((str_t*)tree2)->value );
 		if ( cmpres != 0 )
 			return cmpres;
 	}
@@ -1280,14 +1280,14 @@ long colm_cmp_tree( program_t *prg, const tree_t *tree1, const tree_t *tree2 )
 		else if ( tree1->tokdata != 0 && tree2->tokdata == 0 )
 			return 1;
 		else if ( tree1->tokdata != 0 && tree2->tokdata != 0 ) {
-			cmpres = cmpString( tree1->tokdata, tree2->tokdata );
+			cmpres = cmp_string( tree1->tokdata, tree2->tokdata );
 			if ( cmpres != 0 )
 				return cmpres;
 		}
 	}
 
-	kid_t *kid1 = treeChild( prg, tree1 );
-	kid_t *kid2 = treeChild( prg, tree2 );
+	kid_t *kid1 = tree_child( prg, tree1 );
+	kid_t *kid2 = tree_child( prg, tree2 );
 
 	while ( true ) {
 		if ( kid1 == 0 && kid2 == 0 )
@@ -1307,10 +1307,10 @@ long colm_cmp_tree( program_t *prg, const tree_t *tree1, const tree_t *tree2 )
 }
 
 
-void splitRef( program_t *prg, tree_t ***psp, ref_t *fromRef )
+void split_ref( program_t *prg, tree_t ***psp, ref_t *from_ref )
 {
 	/* Go up the chain of kids, turing the pointers down. */
-	ref_t *last = 0, *ref = fromRef, *next = 0;
+	ref_t *last = 0, *ref = from_ref, *next = 0;
 	while ( ref->next != 0 ) {
 		next = ref->next;
 		ref->next = last;
@@ -1322,33 +1322,33 @@ void splitRef( program_t *prg, tree_t ***psp, ref_t *fromRef )
 	/* Now traverse the list, which goes down. */
 	while ( ref != 0 ) {
 		if ( ref->kid->tree->refs > 1 ) {
-			ref_t *nextDown = ref->next;
-			while ( nextDown != 0 && nextDown->kid == ref->kid )
-				nextDown = nextDown->next;
+			ref_t *next_down = ref->next;
+			while ( next_down != 0 && next_down->kid == ref->kid )
+				next_down = next_down->next;
 
-			kid_t *oldNextKidDown = nextDown != 0 ? nextDown->kid : 0;
-			kid_t *newNextKidDown = 0;
+			kid_t *old_next_kid_down = next_down != 0 ? next_down->kid : 0;
+			kid_t *new_next_kid_down = 0;
 
-			tree_t *newTree = colm_copy_tree( prg, ref->kid->tree, 
-					oldNextKidDown, &newNextKidDown );
-			colm_tree_upref( newTree );
+			tree_t *new_tree = colm_copy_tree( prg, ref->kid->tree, 
+					old_next_kid_down, &new_next_kid_down );
+			colm_tree_upref( new_tree );
 			
 			/* Downref the original. Don't need to consider freeing because
 			 * refs were > 1. */
 			ref->kid->tree->refs -= 1;
 
-			while ( ref != 0 && ref != nextDown ) {
+			while ( ref != 0 && ref != next_down ) {
 				next = ref->next;
 				ref->next = 0;
 
-				ref->kid->tree = newTree;
+				ref->kid->tree = new_tree;
 				ref = next;
 			}
 
 			/* Correct kid pointers down from ref. */
-			while ( nextDown != 0 && nextDown->kid == oldNextKidDown ) {
-				nextDown->kid = newNextKidDown;
-				nextDown = nextDown->next;
+			while ( next_down != 0 && next_down->kid == old_next_kid_down ) {
+				next_down->kid = new_next_kid_down;
+				next_down = next_down->next;
 			}
 		}
 		else {
@@ -1360,7 +1360,7 @@ void splitRef( program_t *prg, tree_t ***psp, ref_t *fromRef )
 	}
 }
 
-tree_t *setListMem( list_t *list, half_t field, tree_t *value )
+tree_t *set_list_mem( list_t *list, half_t field, tree_t *value )
 {
 	if ( value != 0 )
 		assert( value->refs >= 1 );
@@ -1382,13 +1382,13 @@ tree_t *setListMem( list_t *list, half_t field, tree_t *value )
 	return existing;
 }
 
-struct tree_pair mapRemove( program_t *prg, map_t *map, tree_t *key )
+struct tree_pair map_remove( program_t *prg, map_t *map, tree_t *key )
 {
-	map_el_t *mapEl = mapImplFind( prg, map, key );
+	map_el_t *map_el = map_impl_find( prg, map, key );
 	struct tree_pair result = { 0, 0 };
-	if ( mapEl != 0 ) {
-		mapDetach( prg, map, mapEl );
-		result.key = mapEl->key;
+	if ( map_el != 0 ) {
+		map_detach( prg, map, map_el );
+		result.key = map_el->key;
 		//mapElFree( prg, mapEl );
 	}
 
@@ -1396,16 +1396,16 @@ struct tree_pair mapRemove( program_t *prg, map_t *map, tree_t *key )
 }
 
 #if 0
-tree_t *mapUnstore( program_t *prg, map_t *map, tree_t *key, tree_t *existing )
+tree_t *map_unstore( program_t *prg, map_t *map, tree_t *key, tree_t *existing )
 {
 	tree_t *stored = 0;
 	if ( existing == 0 ) {
-		map_el_t *mapEl = mapDetachByKey( prg, map, key );
+		map_el_t *map_el = map_detach_by_key( prg, map, key );
 		// stored = mapEl->tree;
-		mapElFree( prg, mapEl );
+		map_el_free( prg, map_el );
 	}
 	else {
-		map_el_t *mapEl = mapImplFind( prg, map, key );
+		map_el_t *map_el = map_impl_find( prg, map, key );
 		// stored = mapEl->tree;
 		//mapEl->tree = existing;
 	}
@@ -1413,19 +1413,19 @@ tree_t *mapUnstore( program_t *prg, map_t *map, tree_t *key, tree_t *existing )
 }
 #endif
 
-tree_t *mapFind( program_t *prg, map_t *map, tree_t *key )
+tree_t *map_find( program_t *prg, map_t *map, tree_t *key )
 {
 //	map_el_t *mapEl = mapImplFind( prg, map, key );
 //	return mapEl == 0 ? 0 : mapEl->tree;
 	return 0;
 }
 
-long mapLength( map_t *map )
+long map_length( map_t *map )
 {
-	return map->treeSize;
+	return map->tree_size;
 }
 
-void listPushTail( program_t *prg, list_t *list, tree_t *val )
+void list_push_tail( program_t *prg, list_t *list, tree_t *val )
 {
 //	if ( val != 0 )
 //		assert( val->refs >= 1 );
@@ -1434,7 +1434,7 @@ void listPushTail( program_t *prg, list_t *list, tree_t *val )
 //	listAppend( list, listEl );
 }
 
-void listPushHead( program_t *prg, list_t *list, tree_t *val )
+void list_push_head( program_t *prg, list_t *list, tree_t *val )
 {
 //	if ( val != 0 )
 //		assert( val->refs >= 1 );
@@ -1443,7 +1443,7 @@ void listPushHead( program_t *prg, list_t *list, tree_t *val )
 //	listPrepend( list, listEl );
 }
 
-tree_t *listRemoveEnd( program_t *prg, list_t *list )
+tree_t *list_remove_end( program_t *prg, list_t *list )
 {
 //	tree_t *tree = list->tail->value;
 //	listElFree( prg, listDetachLast( list ) );
@@ -1451,7 +1451,7 @@ tree_t *listRemoveEnd( program_t *prg, list_t *list )
 	return 0;
 }
 
-tree_t *listRemoveHead( program_t *prg, list_t *list )
+tree_t *list_remove_head( program_t *prg, list_t *list )
 {
 //	tree_t *tree = list->head;
 //	listDetachFirst( list );
@@ -1459,7 +1459,7 @@ tree_t *listRemoveHead( program_t *prg, list_t *list )
 	return 0;
 }
 
-tree_t *getParserMem( parser_t *parser, word_t field )
+tree_t *get_parser_mem( parser_t *parser, word_t field )
 {
 	tree_t *result = 0;
 	switch ( field ) {
@@ -1468,8 +1468,8 @@ tree_t *getParserMem( parser_t *parser, word_t field )
 			break;
 		}
 		case 1: {
-			struct pda_run *pdaRun = parser->pdaRun;
-			result = pdaRun->parseErrorText;
+			struct pda_run *pda_run = parser->pda_run;
+			result = pda_run->parse_error_text;
 			break;
 		}
 		default: {
@@ -1480,7 +1480,7 @@ tree_t *getParserMem( parser_t *parser, word_t field )
 	return result;
 }
 
-tree_t *getListMemSplit( program_t *prg, list_t *list, word_t field )
+tree_t *get_list_mem_split( program_t *prg, list_t *list, word_t field )
 {
 	tree_t *sv = 0;
 	switch ( field ) {
@@ -1501,11 +1501,11 @@ tree_t *getListMemSplit( program_t *prg, list_t *list, word_t field )
 
 
 #if 0
-int mapInsert( program_t *prg, map_t *map, tree_t *key, tree_t *element )
+int map_insert( program_t *prg, map_t *map, tree_t *key, tree_t *element )
 {
-	map_el_t *mapEl = mapInsertKey( prg, map, key, 0 );
+	map_el_t *map_el = map_insert_key( prg, map, key, 0 );
 
-	if ( mapEl != 0 ) {
+	if ( map_el != 0 ) {
 		//mapEl->tree = element;
 		return true;
 	}
@@ -1515,31 +1515,31 @@ int mapInsert( program_t *prg, map_t *map, tree_t *key, tree_t *element )
 #endif
 
 #if 0
-void mapUnremove( program_t *prg, map_t *map, tree_t *key, tree_t *element )
+void map_unremove( program_t *prg, map_t *map, tree_t *key, tree_t *element )
 {
-	map_el_t *mapEl = mapInsertKey( prg, map, key, 0 );
-	assert( mapEl != 0 );
+	map_el_t *map_el = map_insert_key( prg, map, key, 0 );
+	assert( map_el != 0 );
 	//mapEl->tree = element;
 }
 #endif
 
 #if 0
-tree_t *mapUninsert( program_t *prg, map_t *map, tree_t *key )
+tree_t *map_uninsert( program_t *prg, map_t *map, tree_t *key )
 {
-	map_el_t *el = mapDetachByKey( prg, map, key );
+	map_el_t *el = map_detach_by_key( prg, map, key );
 //	tree_t *val = el->tree;
-	mapElFree( prg, el );
+	map_el_free( prg, el );
 //	return val;
 	return 0;
 }
 #endif
 
 #if 0
-tree_t *mapStore( program_t *prg, map_t *map, tree_t *key, tree_t *element )
+tree_t *map_store( program_t *prg, map_t *map, tree_t *key, tree_t *element )
 {
-	tree_t *oldTree = 0;
-	map_el_t *elInTree = 0;
-	map_el_t *mapEl = mapInsertKey( prg, map, key, &elInTree );
+	tree_t *old_tree = 0;
+	map_el_t *el_in_tree = 0;
+	map_el_t *map_el = map_insert_key( prg, map, key, &el_in_tree );
 
 //	if ( mapEl != 0 )
 //		mapEl->tree = element;
@@ -1549,11 +1549,11 @@ tree_t *mapStore( program_t *prg, map_t *map, tree_t *key, tree_t *element )
 //		elInTree->tree = element;
 //	}
 
-	return oldTree;
+	return old_tree;
 }
 #endif
 
-static tree_t *treeSearchKid( program_t *prg, kid_t *kid, long id )
+static tree_t *tree_search_kid( program_t *prg, kid_t *kid, long id )
 {
 	/* This node the one? */
 	if ( kid->tree->id == id )
@@ -1562,31 +1562,31 @@ static tree_t *treeSearchKid( program_t *prg, kid_t *kid, long id )
 	tree_t *res = 0;
 
 	/* Search children. */
-	kid_t *child = treeChild( prg, kid->tree );
+	kid_t *child = tree_child( prg, kid->tree );
 	if ( child != 0 )
-		res = treeSearchKid( prg, child, id );
+		res = tree_search_kid( prg, child, id );
 	
 	/* Search siblings. */
 	if ( res == 0 && kid->next != 0 )
-		res = treeSearchKid( prg, kid->next, id );
+		res = tree_search_kid( prg, kid->next, id );
 
 	return res;	
 }
 
-tree_t *treeSearch( program_t *prg, tree_t *tree, long id )
+tree_t *tree_search( program_t *prg, tree_t *tree, long id )
 {
 	tree_t *res = 0;
 	if ( tree->id == id )
 		res = tree;
 	else {
-		kid_t *child = treeChild( prg, tree );
+		kid_t *child = tree_child( prg, tree );
 		if ( child != 0 )
-			res = treeSearchKid( prg, child, id );
+			res = tree_search_kid( prg, child, id );
 	}
 	return res;
 }
 
-static location_t *locSearchKid( program_t *prg, kid_t *kid )
+static location_t *loc_search_kid( program_t *prg, kid_t *kid )
 {
 	/* This node the one? */
 	if ( kid->tree->tokdata != 0 && kid->tree->tokdata->location != 0 )
@@ -1595,108 +1595,108 @@ static location_t *locSearchKid( program_t *prg, kid_t *kid )
 	location_t *res = 0;
 
 	/* Search children. */
-	kid_t *child = treeChild( prg, kid->tree );
+	kid_t *child = tree_child( prg, kid->tree );
 	if ( child != 0 )
-		res = locSearchKid( prg, child );
+		res = loc_search_kid( prg, child );
 	
 	/* Search siblings. */
 	if ( res == 0 && kid->next != 0 )
-		res = locSearchKid( prg, kid->next );
+		res = loc_search_kid( prg, kid->next );
 
 	return res;	
 }
 
-location_t *locSearch( program_t *prg, tree_t *tree )
+location_t *loc_search( program_t *prg, tree_t *tree )
 {
 	location_t *res = 0;
 	if ( tree->tokdata != 0 && tree->tokdata->location != 0 )
 		return tree->tokdata->location;
 
-	kid_t *child = treeChild( prg, tree );
+	kid_t *child = tree_child( prg, tree );
 	if ( child != 0 )
-		res = locSearchKid( prg, child );
+		res = loc_search_kid( prg, child );
 
 	return res;
 }
 
 struct colm_location *colm_find_location( program_t *prg, tree_t *tree )
 {
-	return locSearch( prg, tree );
+	return loc_search( prg, tree );
 }
 
 /*
  * tree_t Printing
  */
 
-void xmlEscapeData( struct colm_print_args *printArgs, const char *data, long len )
+void xml_escape_data( struct colm_print_args *print_args, const char *data, long len )
 {
 	int i;
 	for ( i = 0; i < len; i++ ) {
 		if ( data[i] == '<' )
-			printArgs->out( printArgs, "&lt;", 4 );
+			print_args->out( print_args, "&lt;", 4 );
 		else if ( data[i] == '>' )
-			printArgs->out( printArgs, "&gt;", 4 );
+			print_args->out( print_args, "&gt;", 4 );
 		else if ( data[i] == '&' )
-			printArgs->out( printArgs, "&amp;", 5 );
+			print_args->out( print_args, "&amp;", 5 );
 		else if ( (32 <= data[i] && data[i] <= 126) || 
 				data[i] == '\t' || data[i] == '\n' || data[i] == '\r' )
 		{
-			printArgs->out( printArgs, &data[i], 1 );
+			print_args->out( print_args, &data[i], 1 );
 		}
 		else {
 			char out[64];
 			sprintf( out, "&#%u;", ((unsigned)data[i]) );
-			printArgs->out( printArgs, out, strlen(out) );
+			print_args->out( print_args, out, strlen(out) );
 		}
 	}
 }
 
-void initStrCollect( StrCollect *collect )
+void init_str_collect( StrCollect *collect )
 {
 	collect->data = (char*) malloc( BUFFER_INITIAL_SIZE );
 	collect->allocated = BUFFER_INITIAL_SIZE;
 	collect->length = 0;
 }
 
-void strCollectDestroy( StrCollect *collect )
+void str_collect_destroy( StrCollect *collect )
 {
 	free( collect->data );
 }
 
-void strCollectAppend( StrCollect *collect, const char *data, long len )
+void str_collect_append( StrCollect *collect, const char *data, long len )
 {
-	long newLen = collect->length + len;
-	if ( newLen > collect->allocated ) {
-		collect->allocated = newLen * 2;
+	long new_len = collect->length + len;
+	if ( new_len > collect->allocated ) {
+		collect->allocated = new_len * 2;
 		collect->data = (char*) realloc( collect->data, collect->allocated );
 	}
 	memcpy( collect->data + collect->length, data, len );
 	collect->length += len;
 }
 		
-void strCollectClear( StrCollect *collect )
+void str_collect_clear( StrCollect *collect )
 {
 	collect->length = 0;
 }
 
 #define INT_SZ 32
 
-void printStr( struct colm_print_args *printArgs, head_t *str )
+void print_str( struct colm_print_args *print_args, head_t *str )
 {
-	printArgs->out( printArgs, (char*)(str->data), str->length );
+	print_args->out( print_args, (char*)(str->data), str->length );
 }
 
-void appendCollect( struct colm_print_args *args, const char *data, int length )
+void append_collect( struct colm_print_args *args, const char *data, int length )
 {
-	strCollectAppend( (StrCollect*) args->arg, data, length );
+	str_collect_append( (StrCollect*) args->arg, data, length );
 }
 
-void appendFile( struct colm_print_args *args, const char *data, int length )
+void append_file( struct colm_print_args *args, const char *data, int length )
 {
 	fwrite( data, 1, length, (FILE*)args->arg );
 }
 
-void appendFd( struct colm_print_args *args, const char *data, int length )
+void append_fd( struct colm_print_args *args, const char *data, int length )
 {
 	int fd = (long)args->arg;
 	int res = write( fd, data, length );
@@ -1704,27 +1704,27 @@ void appendFd( struct colm_print_args *args, const char *data, int length )
 		message( "write error on fd: %d: %s\n", fd, strerror(errno) );
 }
 
-tree_t *treeTrim( struct colm_program *prg, tree_t **sp, tree_t *tree )
+tree_t *tree_trim( struct colm_program *prg, tree_t **sp, tree_t *tree )
 {
 	debug( prg, REALM_PARSE, "attaching left ignore\n" );
 
 	/* Make the ignore list for the left-ignore. */
-	tree_t *leftIgnore = tree_allocate( prg );
-	leftIgnore->id = LEL_ID_IGNORE;
-	leftIgnore->flags |= AF_SUPPRESS_RIGHT;
+	tree_t *left_ignore = tree_allocate( prg );
+	left_ignore->id = LEL_ID_IGNORE;
+	left_ignore->flags |= AF_SUPPRESS_RIGHT;
 
-	tree = push_left_ignore( prg, tree, leftIgnore );
+	tree = push_left_ignore( prg, tree, left_ignore );
 
 	debug( prg, REALM_PARSE, "attaching ignore right\n" );
 
 	/* Copy the ignore list first if we need to attach it as a right
 	 * ignore. */
-	tree_t *rightIgnore = 0;
-	rightIgnore = tree_allocate( prg );
-	rightIgnore->id = LEL_ID_IGNORE;
-	rightIgnore->flags |= AF_SUPPRESS_LEFT;
+	tree_t *right_ignore = 0;
+	right_ignore = tree_allocate( prg );
+	right_ignore->id = LEL_ID_IGNORE;
+	right_ignore->flags |= AF_SUPPRESS_LEFT;
 
-	tree = push_right_ignore( prg, tree, rightIgnore );
+	tree = push_right_ignore( prg, tree, right_ignore );
 
 	return tree;
 }
@@ -1748,12 +1748,12 @@ enum VisitType
 
 #define TF_TERM_SEEN 0x1
 
-void printKid( program_t *prg, tree_t **sp, struct colm_print_args *printArgs, kid_t *kid )
+void print_kid( program_t *prg, tree_t **sp, struct colm_print_args *print_args, kid_t *kid )
 {
 	enum ReturnType rt;
 	kid_t *parent = 0;
-	kid_t *leadingIgnore = 0;
-	enum VisitType visitType;
+	kid_t *leading_ignore = 0;
+	enum VisitType visit_type;
 	int flags = 0;
 
 	/* Iterate the kids passed in. We are expecting a next, which will allow us
@@ -1777,7 +1777,7 @@ rec_call:
 		vm_push_kid( parent );
 		vm_push_kid( kid );
 		parent = kid;
-		kid = treeLeftIgnoreKid( prg, kid->tree );
+		kid = tree_left_ignore_kid( prg, kid->tree );
 		vm_push_type( enum ReturnType, CollectIgnoreLeft );
 		goto rec_call;
 		rec_return_ign_left:
@@ -1786,75 +1786,75 @@ rec_call:
 	}
 
 	if ( kid->tree->id == LEL_ID_IGNORE )
-		visitType = IgnoreWrapper;
+		visit_type = IgnoreWrapper;
 	else if ( parent != 0 && parent->tree->id == LEL_ID_IGNORE )
-		visitType = IgnoreData;
-	else if ( kid->tree->id < prg->rtd->firstNonTermId )
-		visitType = Term;
+		visit_type = IgnoreData;
+	else if ( kid->tree->id < prg->rtd->first_non_term_id )
+		visit_type = Term;
 	else
-		visitType = NonTerm;
+		visit_type = NonTerm;
 	
-	debug( prg, REALM_PRINT, "visit type: %d\n", visitType );
+	debug( prg, REALM_PRINT, "visit type: %d\n", visit_type );
 
-	if ( visitType == IgnoreData ) {
+	if ( visit_type == IgnoreData ) {
 		debug( prg, REALM_PRINT, "putting %p on ignore list\n", kid->tree );
-		kid_t *newIgnore = kid_allocate( prg );
-		newIgnore->next = leadingIgnore;
-		leadingIgnore = newIgnore;
-		leadingIgnore->tree = kid->tree;
+		kid_t *new_ignore = kid_allocate( prg );
+		new_ignore->next = leading_ignore;
+		leading_ignore = new_ignore;
+		leading_ignore->tree = kid->tree;
 		goto skip_node;
 	}
 
-	if ( visitType == IgnoreWrapper ) {
-		kid_t *newIgnore = kid_allocate( prg );
-		newIgnore->next = leadingIgnore;
-		leadingIgnore = newIgnore;
-		leadingIgnore->tree = kid->tree;
+	if ( visit_type == IgnoreWrapper ) {
+		kid_t *new_ignore = kid_allocate( prg );
+		new_ignore->next = leading_ignore;
+		leading_ignore = new_ignore;
+		leading_ignore->tree = kid->tree;
 		/* Don't skip. */
 	}
 
 	/* print leading ignore? Triggered by terminals. */
-	if ( visitType == Term ) {
+	if ( visit_type == Term ) {
 		/* Reverse the leading ignore list. */
-		if ( leadingIgnore != 0 ) {
+		if ( leading_ignore != 0 ) {
 			kid_t *ignore = 0, *last = 0;
 
 			/* Reverse the list and take the opportunity to implement the
 			 * suppress left. */
 			while ( true ) {
-				kid_t *next = leadingIgnore->next;
-				leadingIgnore->next = last;
+				kid_t *next = leading_ignore->next;
+				leading_ignore->next = last;
 
-				if ( leadingIgnore->tree->flags & AF_SUPPRESS_LEFT ) {
+				if ( leading_ignore->tree->flags & AF_SUPPRESS_LEFT ) {
 					/* We are moving left. Chop off the tail. */
 					debug( prg, REALM_PRINT, "suppressing left\n" );
-					freeKidList( prg, next );
+					free_kid_list( prg, next );
 					break;
 				}
 
 				if ( next == 0 )
 					break;
 
-				last = leadingIgnore;
-				leadingIgnore = next;
+				last = leading_ignore;
+				leading_ignore = next;
 			}
 
 			/* Print the leading ignore list. Also implement the suppress right
 			 * in the process. */
-			if ( printArgs->comm && (!printArgs->trim || (flags & TF_TERM_SEEN && kid->tree->id > 0)) ) {	
-				ignore = leadingIgnore;
+			if ( print_args->comm && (!print_args->trim || (flags & TF_TERM_SEEN && kid->tree->id > 0)) ) {	
+				ignore = leading_ignore;
 				while ( ignore != 0 ) {
 					if ( ignore->tree->flags & AF_SUPPRESS_RIGHT )
 						break;
 
 					if ( ignore->tree->id != LEL_ID_IGNORE ) {
-						vm_push_type( enum VisitType, visitType );
-						vm_push_kid( leadingIgnore );
+						vm_push_type( enum VisitType, visit_type );
+						vm_push_kid( leading_ignore );
 						vm_push_kid( ignore );
 						vm_push_kid( parent );
 						vm_push_kid( kid );
 
-						leadingIgnore = 0;
+						leading_ignore = 0;
 						kid = ignore;
 						parent = 0;
 
@@ -1866,8 +1866,8 @@ rec_call:
 						kid = vm_pop_kid();
 						parent = vm_pop_kid();
 						ignore = vm_pop_kid();
-						leadingIgnore = vm_pop_kid();
-						visitType = vm_pop_type(enum VisitType);
+						leading_ignore = vm_pop_kid();
+						visit_type = vm_pop_type(enum VisitType);
 					}
 
 					ignore = ignore->next;
@@ -1875,35 +1875,35 @@ rec_call:
 			}
 
 			/* Free the leading ignore list. */
-			freeKidList( prg, leadingIgnore );
-			leadingIgnore = 0;
+			free_kid_list( prg, leading_ignore );
+			leading_ignore = 0;
 		}
 	}
 
-	if ( visitType == Term || visitType == NonTerm ) {
+	if ( visit_type == Term || visit_type == NonTerm ) {
 		/* Open the tree. */
-		printArgs->open_tree( prg, sp, printArgs, parent, kid );
+		print_args->open_tree( prg, sp, print_args, parent, kid );
 	}
 
-	if ( visitType == Term )
+	if ( visit_type == Term )
 		flags |= TF_TERM_SEEN;
 
-	if ( visitType == Term || visitType == IgnoreData ) {
+	if ( visit_type == Term || visit_type == IgnoreData ) {
 		/* Print contents. */
-		if ( kid->tree->id < prg->rtd->firstNonTermId ) {
+		if ( kid->tree->id < prg->rtd->first_non_term_id ) {
 			debug( prg, REALM_PRINT, "printing terminal %p\n", kid->tree );
 			if ( kid->tree->id != 0 )
-				printArgs->print_term( prg, sp, printArgs, kid );
+				print_args->print_term( prg, sp, print_args, kid );
 		}
 	}
 
 	/* Print children. */
-	kid_t *child = printArgs->attr ? 
-		treeAttr( prg, kid->tree ) : 
-		treeChild( prg, kid->tree );
+	kid_t *child = print_args->attr ? 
+		tree_attr( prg, kid->tree ) : 
+		tree_child( prg, kid->tree );
 
 	if ( child != 0 ) {
-		vm_push_type( enum VisitType, visitType );
+		vm_push_type( enum VisitType, visit_type );
 		vm_push_kid( parent );
 		vm_push_kid( kid );
 		parent = kid;
@@ -1916,12 +1916,12 @@ rec_call:
 		}
 		kid = vm_pop_kid();
 		parent = vm_pop_kid();
-		visitType = vm_pop_type(enum VisitType);
+		visit_type = vm_pop_type(enum VisitType);
 	}
 
-	if ( visitType == Term || visitType == NonTerm ) {
+	if ( visit_type == Term || visit_type == NonTerm ) {
 		/* close the tree. */
-		printArgs->close_tree( prg, sp, printArgs, parent, kid );
+		print_args->close_tree( prg, sp, print_args, parent, kid );
 	}
 
 skip_node:
@@ -1933,7 +1933,7 @@ skip_node:
 		vm_push_kid( parent );
 		vm_push_kid( kid );
 		parent = kid;
-		kid = treeRightIgnoreKid( prg, kid->tree );
+		kid = tree_right_ignore_kid( prg, kid->tree );
 		vm_push_type( enum ReturnType, CollectIgnoreRight );
 		goto rec_call;
 		rec_return_ign_right:
@@ -1965,17 +1965,17 @@ skip_null:
 	}
 }
 
-void colm_print_tree_args( program_t *prg, tree_t **sp, struct colm_print_args *printArgs, tree_t *tree )
+void colm_print_tree_args( program_t *prg, tree_t **sp, struct colm_print_args *print_args, tree_t *tree )
 {
 	if ( tree == 0 )
-		printArgs->out( printArgs, "NIL", 3 );
+		print_args->out( print_args, "NIL", 3 );
 	else {
 		/* This term tree allows us to print trailing ignores. */
-		tree_t termTree;
-		memset( &termTree, 0, sizeof(termTree) );
+		tree_t term_tree;
+		memset( &term_tree, 0, sizeof(term_tree) );
 
 		kid_t kid, term;
-		term.tree = &termTree;
+		term.tree = &term_tree;
 		term.next = 0;
 		term.flags = 0;
 
@@ -1983,22 +1983,22 @@ void colm_print_tree_args( program_t *prg, tree_t **sp, struct colm_print_args *
 		kid.next = &term;
 		kid.flags = 0;
 
-		printKid( prg, sp, printArgs, &kid );
+		print_kid( prg, sp, print_args, &kid );
 	}
 }
 
-void colm_print_term_tree( program_t *prg, tree_t **sp, struct colm_print_args *printArgs, kid_t *kid )
+void colm_print_term_tree( program_t *prg, tree_t **sp, struct colm_print_args *print_args, kid_t *kid )
 {
 	debug( prg, REALM_PRINT, "printing term %p\n", kid->tree );
 
 	if ( kid->tree->id == LEL_ID_PTR ) {
 		char buf[INT_SZ];
-		printArgs->out( printArgs, "#", 1 );
+		print_args->out( print_args, "#", 1 );
 		sprintf( buf, "%p", (void*) ((pointer_t*)kid->tree)->value );
-		printArgs->out( printArgs, buf, strlen(buf) );
+		print_args->out( print_args, buf, strlen(buf) );
 	}
 	else if ( kid->tree->id == LEL_ID_STR ) {
-		printStr( printArgs, ((str_t*)kid->tree)->value );
+		print_str( print_args, ((str_t*)kid->tree)->value );
 	}
 //	else if ( kid->tree->id == LEL_ID_STREAM ) {
 //		char buf[INT_SZ];
@@ -2007,10 +2007,10 @@ void colm_print_term_tree( program_t *prg, tree_t **sp, struct colm_print_args *
 //		printArgs->out( printArgs, buf, strlen(buf) );
 //	}
 	else if ( kid->tree->tokdata != 0 && 
-			stringLength( kid->tree->tokdata ) > 0 )
+			string_length( kid->tree->tokdata ) > 0 )
 	{
-		printArgs->out( printArgs, stringData( kid->tree->tokdata ), 
-				stringLength( kid->tree->tokdata ) );
+		print_args->out( print_args, string_data( kid->tree->tokdata ), 
+				string_length( kid->tree->tokdata ) );
 	}
 }
 
@@ -2020,103 +2020,103 @@ void colm_print_null( program_t *prg, tree_t **sp,
 {
 }
 
-void openTreeXml( program_t *prg, tree_t **sp, struct colm_print_args *args,
+void open_tree_xml( program_t *prg, tree_t **sp, struct colm_print_args *args,
 		kid_t *parent, kid_t *kid )
 {
 	/* Skip the terminal that is for forcing trailing ignores out. */
 	if ( kid->tree->id == 0 )
 		return;
 
-	struct lang_el_info *lelInfo = prg->rtd->lelInfo;
+	struct lang_el_info *lel_info = prg->rtd->lel_info;
 
 	/* List flattening: skip the repeats and lists that are a continuation of
 	 * the list. */
 	if ( parent != 0 && parent->tree->id == kid->tree->id && kid->next == 0 &&
-			( lelInfo[parent->tree->id].repeat || lelInfo[parent->tree->id].list ) )
+			( lel_info[parent->tree->id].repeat || lel_info[parent->tree->id].list ) )
 	{
 		return;
 	}
 
-	const char *name = lelInfo[kid->tree->id].xmlTag;
+	const char *name = lel_info[kid->tree->id].xml_tag;
 	args->out( args, "<", 1 );
 	args->out( args, name, strlen( name ) );
 	args->out( args, ">", 1 );
 }
 
-void printTermXml( program_t *prg, tree_t **sp, struct colm_print_args *printArgs, kid_t *kid )
+void print_term_xml( program_t *prg, tree_t **sp, struct colm_print_args *print_args, kid_t *kid )
 {
 	//kid_t *child;
 
-	/*child = */ treeChild( prg, kid->tree );
+	/*child = */ tree_child( prg, kid->tree );
 	if ( kid->tree->id == LEL_ID_PTR ) {
 		char ptr[32];
 		sprintf( ptr, "%p\n", (void*)((pointer_t*)kid->tree)->value );
-		printArgs->out( printArgs, ptr, strlen(ptr) );
+		print_args->out( print_args, ptr, strlen(ptr) );
 	}
 	else if ( kid->tree->id == LEL_ID_STR ) {
 		head_t *head = (head_t*) ((str_t*)kid->tree)->value;
 
-		xmlEscapeData( printArgs, (char*)(head->data), head->length );
+		xml_escape_data( print_args, (char*)(head->data), head->length );
 	}
-	else if ( 0 < kid->tree->id && kid->tree->id < prg->rtd->firstNonTermId &&
+	else if ( 0 < kid->tree->id && kid->tree->id < prg->rtd->first_non_term_id &&
 			kid->tree->id != LEL_ID_IGNORE &&
 			kid->tree->tokdata != 0 && 
-			stringLength( kid->tree->tokdata ) > 0 )
+			string_length( kid->tree->tokdata ) > 0 )
 	{
-		xmlEscapeData( printArgs, stringData( kid->tree->tokdata ), 
-				stringLength( kid->tree->tokdata ) );
+		xml_escape_data( print_args, string_data( kid->tree->tokdata ), 
+				string_length( kid->tree->tokdata ) );
 	}
 }
 
 
-void closeTreeXml( program_t *prg, tree_t **sp, struct colm_print_args *args, kid_t *parent, kid_t *kid )
+void close_tree_xml( program_t *prg, tree_t **sp, struct colm_print_args *args, kid_t *parent, kid_t *kid )
 {
 	/* Skip the terminal that is for forcing trailing ignores out. */
 	if ( kid->tree->id == 0 )
 		return;
 
-	struct lang_el_info *lelInfo = prg->rtd->lelInfo;
+	struct lang_el_info *lel_info = prg->rtd->lel_info;
 
 	/* List flattening: skip the repeats and lists that are a continuation of
 	 * the list. */
 	if ( parent != 0 && parent->tree->id == kid->tree->id && kid->next == 0 &&
-			( lelInfo[parent->tree->id].repeat || lelInfo[parent->tree->id].list ) )
+			( lel_info[parent->tree->id].repeat || lel_info[parent->tree->id].list ) )
 	{
 		return;
 	}
 
-	const char *name = lelInfo[kid->tree->id].xmlTag;
+	const char *name = lel_info[kid->tree->id].xml_tag;
 	args->out( args, "</", 2 );
 	args->out( args, name, strlen( name ) );
 	args->out( args, ">", 1 );
 }
 
-void printTreeCollect( program_t *prg, tree_t **sp, StrCollect *collect, tree_t *tree, int trim )
+void print_tree_collect( program_t *prg, tree_t **sp, StrCollect *collect, tree_t *tree, int trim )
 {
-	struct colm_print_args printArgs = { collect, true, false, trim, &appendCollect, 
+	struct colm_print_args print_args = { collect, true, false, trim, &append_collect, 
 			&colm_print_null, &colm_print_term_tree, &colm_print_null };
-	colm_print_tree_args( prg, sp, &printArgs, tree );
+	colm_print_tree_args( prg, sp, &print_args, tree );
 }
 
-void printTreeFile( program_t *prg, tree_t **sp, FILE *out, tree_t *tree, int trim )
+void print_tree_file( program_t *prg, tree_t **sp, FILE *out, tree_t *tree, int trim )
 {
-	struct colm_print_args printArgs = { out, true, false, trim, &appendFile, 
+	struct colm_print_args print_args = { out, true, false, trim, &append_file, 
 			&colm_print_null, &colm_print_term_tree, &colm_print_null };
-	colm_print_tree_args( prg, sp, &printArgs, tree );
+	colm_print_tree_args( prg, sp, &print_args, tree );
 }
 
-void printTreeFd( program_t *prg, tree_t **sp, int fd, tree_t *tree, int trim )
+void print_tree_fd( program_t *prg, tree_t **sp, int fd, tree_t *tree, int trim )
 {
-	struct colm_print_args printArgs = { (void*)((long)fd), true, false, trim, &appendFd,
+	struct colm_print_args print_args = { (void*)((long)fd), true, false, trim, &append_fd,
 			&colm_print_null, &colm_print_term_tree, &colm_print_null };
-	colm_print_tree_args( prg, sp, &printArgs, tree );
+	colm_print_tree_args( prg, sp, &print_args, tree );
 }
 
-void printXmlStdout( program_t *prg, tree_t **sp, tree_t *tree, int commAttr, int trim )
+void print_xml_stdout( program_t *prg, tree_t **sp, tree_t *tree, int comm_attr, int trim )
 {
-	struct colm_print_args printArgs = { stdout, commAttr, commAttr, trim, &appendFile, 
-			&openTreeXml, &printTermXml, &closeTreeXml };
-	colm_print_tree_args( prg, sp, &printArgs, tree );
+	struct colm_print_args print_args = { stdout, comm_attr, comm_attr, trim, &append_file, 
+			&open_tree_xml, &print_term_xml, &close_tree_xml };
+	colm_print_tree_args( prg, sp, &print_args, tree );
 }