Formated

Code now follows the style guide.

1 files changed, 232 insertions, 231 deletions

diff --git a/ctemplates.c b/ctemplates.c
index 77832e6..add05f3 100644
--- a/ctemplates.c
+++ b/ctemplates.c
@@ -6,8 +6,20 @@
  *
  * Copyright (c) 2017 Alexander M. Pickering (alexandermpickering@gmail.com)
  *
- * Distributed under the terms of the GNU General Public Liscense
- * (GPL). See COPYING for more information.
+ * Distributed under GPL V3, see COPYING for more information.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as publish by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public Liscense for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
@@ -20,16 +32,135 @@
 #include <stdarg.h>
 #include <ctemplates_i.h>
 
-void TMPL_free_loop(struct TMPL_loop* tl);
+struct TMPL_token*           TMPL_alloc_token();
+void                         TMPL_free_token(struct TMPL_token* token);
+enum TMPL_tagtype            starts_with_token(char* str, size_t strlen);
+size_t                       tagtype_len(enum TMPL_tagtype t);
+struct TMPL_token*           scan_text(
+                                       char* start,
+                                       size_t strlen,
+                                       size_t* consumed
+                                      );
+struct TMPL_token*           scan_tag(
+                                      char* start,
+                                      size_t strlen,
+                                      size_t* consumed
+                                     );
+void                         print_tokens(struct TMPL_token* head);
+struct TMPL_varitem*         TMPL_alloc_varitem();
+void                         TMPL_free_varitem(struct TMPL_varitem* vi);
+void                         TMPL_add_var_to_varlist(
+                                                     struct TMPL_varlist* t,
+                                                     char* varname,
+                                                     char* var
+                                                    );
+void                         print_ast_helper(
+                                              struct TMPL_tagnode* cursor,
+                                              int level
+                                             );
+void                         print_ast(struct TMPL_tagnode* root);
+struct TMPL_token*           TMPL_tokenize(char* tmplstr, size_t strlen);
+struct TMPL_tagnode*         alloc_tagnode();
+size_t                       get_quoted_string(char* start, size_t len);
+struct TMPL_tagnode*         parse_text(
+                                        struct TMPL_token* head,
+                                        struct TMPL_buf* errbuf
+                                       );
+struct TMPL_tagnode*         parse_else(
+                                        struct TMPL_token* head,
+                                        struct TMPL_buf* errbuf
+                                       );
+struct TMPL_tagnode*         parse_elseif(
+                                          struct TMPL_token* head,
+                                          struct TMPL_buf* errbuf
+                                         );
+struct TMPL_tagnode*         parse_if(
+                                      struct TMPL_token* head,
+                                      struct TMPL_buf* errbuf
+                                     );
+struct TMPL_tagnode*         parse_loop(
+                                        struct TMPL_token* head,
+                                        struct TMPL_buf* errbuf
+                                       );
+struct TMPL_tagnode*         parse_variable(
+                                            struct TMPL_token* head,
+                                            struct TMPL_buf* errbuf
+                                           );
+struct TMPL_varlist*         TMPL_alloc_varlist();
+int                          TMPL_free_hashmapitems(any_t a, any_t b);
+void                         TMPL_free_varlist(struct TMPL_varlist* vl);
+struct TMPL_loop*            TMPL_alloc_loop();
+void                         TMPL_free_loop(struct TMPL_loop* tl);
+void                         TMPL_add_varlist_to_loop(
+                                                      struct TMPL_loop* tl,
+                                                      struct TMPL_varlist* vl
+                                                     );
+void                         TMPL_add_loop_to_varlist(
+                                                      struct TMPL_varlist* vl,
+                                                      char* name,
+                                                      struct TMPL_loop* l
+                                                     );
+struct TMPL_tagnode*         parse(
+                                   struct TMPL_token* head,
+                                   struct TMPL_buf* errbuf
+                                  );
+struct TMPL_templates*       alloc_templates();
+struct TMPL_templates*       compile(char* tmplstr);
+int                          render_variable(
+                                             struct TMPL_templates* t,
+                                             struct TMPL_tagnode* node,
+                                             struct TMPL_varlist* varlist
+                                            );
+int                          render_text(
+                                         struct TMPL_templates* t,
+                                         struct TMPL_tagnode* node,
+                                         struct TMPL_varlist* varlist
+                                        );
+int                          print_pair(any_t indent, any_t b);
+int                          render_if(
+                                       struct TMPL_templates* t,
+                                       struct TMPL_tagnode* node,
+                                       struct TMPL_varlist* varlist
+                                      );
+int                          render_elseif(
+                                           struct TMPL_templates* t,
+                                           struct TMPL_tagnode* node,
+                                           struct TMPL_varlist* varlist
+                                          );
+int                          render_loop(
+                                         struct TMPL_templates* t,
+                                         struct TMPL_tagnode* node,
+                                         struct TMPL_varlist* varlist
+                                        );
+int                          render_any(
+                                        struct TMPL_templates* t,
+                                        struct TMPL_tagnode* node,
+                                        struct TMPL_varlist* varlist
+                                       );
+void                         TMPL_render_helper(
+                                                struct TMPL_templates* t,
+                                                struct TMPL_varlist* varlist
+                                               );
+char*                        TMPL_render(
+                                         struct TMPL_templates* t,
+                                         struct TMPL_varlist* varlist
+                                        );
+struct TMPL_templates*       TMPL_alloc_template(char* tmplstr);
+void                         TMPL_free_template(struct TMPL_templates* t);
+void                         TMPL_free_tagnode(struct TMPL_tagnode* tn);
+char*                        TMPL_get_error(struct TMPL_templates* t);
+
 
 /*Allocates a token*/
-struct TMPL_token* TMPL_alloc_token(){
+struct TMPL_token*
+TMPL_alloc_token(){
 	struct TMPL_token* ret = (struct TMPL_token*)malloc(sizeof(struct TMPL_token));
 	ret->next = NULL;
 	return ret;
 }
 /*Frees an allocated token*/
-void TMPL_free_token(struct TMPL_token* token){
+void
+TMPL_free_token(struct TMPL_token* token){
 	struct TMPL_token* cursor = token;
 	while(cursor != NULL){
 		struct TMPL_token* this = cursor;
@@ -39,8 +170,9 @@ void TMPL_free_token(struct TMPL_token* token){
 }
 
 /*Check if it starts with the names of any of our tokens*/
-enum TMPL_tagtype starts_with_token(char* str, size_t strlen){
-	//Make sure we get TMPL_ first
+enum TMPL_tagtype
+starts_with_token(char* str, size_t strlen){
+	/*Make sure we get TMPL_ first*/
 	if(strlen < 5){
 		return tag_null;
 	}
@@ -68,7 +200,7 @@ enum TMPL_tagtype starts_with_token(char* str, size_t strlen){
 	&& *(str + 7) == 'D'){
 		return tag_end;
 	}else if(strlen > TAG_ELSE_LENGTH
-	&& *(str + 5) == 'E'//Check for both else and elseif
+	&& *(str + 5) == 'E'/*Check for both else and elseif*/
 	&& *(str + 6) == 'L'
 	&& *(str + 7) == 'S'
 	&& *(str + 8) == 'E'){
@@ -114,7 +246,8 @@ enum TMPL_tagtype starts_with_token(char* str, size_t strlen){
 }
 
 /*Find the lenth of a tag*/
-size_t tagtype_len(enum TMPL_tagtype t){
+size_t
+tagtype_len(enum TMPL_tagtype t){
 	switch(t){
 		case tag_null:
 			return TAG_NULL_LENGTH;
@@ -141,9 +274,8 @@ size_t tagtype_len(enum TMPL_tagtype t){
 }
 
 /*Quickly find the token*/
-struct TMPL_token* scan_text(char* start, size_t strlen, size_t* consumed){
-	//printf("Scan starting at %p\n",start);
-	//printf("Size of string was %d \"%s\"\n",(int)strlen,start);
+struct TMPL_token*
+scan_text(char* start, size_t strlen, size_t* consumed){
 	struct TMPL_token* t = TMPL_alloc_token();
 	t->start = start;
 	enum TMPL_tagtype type = tag_null;
@@ -151,11 +283,9 @@ struct TMPL_token* scan_text(char* start, size_t strlen, size_t* consumed){
 	while(type == tag_null){
 		cursor = (char*)memchr(cursor,'<',strlen);
 		if(cursor == NULL){
-			//printf("Cursor was null\n");
 			cursor = start + (strlen > 0 ? strlen : 1);
 			break;
 		}
-		//printf("Return of memchr was %s\n",cursor);
 		type = starts_with_token(cursor+1,strlen);
 		if(type == tag_null){
 			cursor++;
@@ -164,29 +294,25 @@ struct TMPL_token* scan_text(char* start, size_t strlen, size_t* consumed){
 	t->end = cursor;
 	t->length = t->end - t->start;
 	*consumed = t->length;
-	//printf("Consumed length is %d\n",(int)*consumed);
-	//printf("Scan_text is returning token:\n");
 	char* c;
 	for(c = start; c < cursor; c++){
-		//printf("%c",*c);
 	}
-	//printf("\n");
 	return t;
 }
 
-struct TMPL_token* scan_tag(char* start, size_t strlen, size_t* consumed){
-	//printf("Scanning tag\n");
+struct TMPL_token*
+scan_tag(char* start, size_t strlen, size_t* consumed){
 	struct TMPL_token* t = TMPL_alloc_token();
 	t->start = start;
 	char* cursor = (char*)memchr(start,'>',strlen);
-	//printf("Managed to get through memchr, cursor is now %s\n",cursor);
-	t->end = cursor+1;//Include the '>'
+	t->end = cursor+1;/*Include the '>'*/
 	t->length = t->end - t->start;
 	*consumed = t->length;
 	return t;
 }
 
-void print_tokens(struct TMPL_token* head){
+void
+print_tokens(struct TMPL_token* head){
 	struct TMPL_token* cursor = head;
 	while(cursor != NULL){
 		printf("char start is %p char end is %p cursor is %p type is %d\n",cursor->start, cursor->end,(void*)cursor,(int)cursor->type);
@@ -200,25 +326,24 @@ void print_tokens(struct TMPL_token* head){
 	printf("Finished printing tokens\n");
 }
 
-struct TMPL_varitem* TMPL_alloc_varitem(){
+struct TMPL_varitem*
+TMPL_alloc_varitem(){
 	struct TMPL_varitem* ret = (struct TMPL_varitem*)malloc(sizeof(struct TMPL_varitem));
 	return ret;
 }
 
-void TMPL_free_varitem(struct TMPL_varitem* vi){
-	//printf("Freeing varitem\n");
+void
+TMPL_free_varitem(struct TMPL_varitem* vi){
 	if(vi->type == vartype_var){
-		////printf("Freeing string at %p(%s)\n",vi->item.s,vi->item.s);
-		//free(vi->item.s);
+		free(vi->item.s);
 	}else{
-		//printf("Freeing loop\n");
 		TMPL_free_loop(vi->item.l);
 	}
 	free(vi);
 }
 
-void TMPL_add_var_to_varlist(struct TMPL_varlist* t, char* varname, char* var){
-	//printf("Adding \"%s\" to varlist under \"%s\"(%p)\n",var,varname,(void*)varname);
+void
+TMPL_add_var_to_varlist(struct TMPL_varlist* t, char* varname, char* var){
 	struct TMPL_varitem* vi = TMPL_alloc_varitem();
 	vi->type = vartype_var;
 	size_t slen = strlen(var);
@@ -226,13 +351,12 @@ void TMPL_add_var_to_varlist(struct TMPL_varlist* t, char* varname, char* var){
 	memcpy(vi->item.s,var,slen);
 	int succ = hashmap_put(t->map,varname,vi);
 	if(succ != MAP_OK){
-		//printf("FAiled to put item in %d\n",succ);
 		exit(-1);
 	}
-	//printf("Done\n");
 }
 
-void print_ast_helper(struct TMPL_tagnode* cursor, int level){
+void
+print_ast_helper(struct TMPL_tagnode* cursor, int level){
 	int i;
 	for(i = 0; i < level; i++){
 		printf("|");
@@ -291,18 +415,19 @@ void print_ast_helper(struct TMPL_tagnode* cursor, int level){
 		print_ast_helper(cursor->next,level);
 	}
 }
-void print_ast(struct TMPL_tagnode* root){
+void
+print_ast(struct TMPL_tagnode* root){
 	print_ast_helper(root,0);
 }
 
-struct TMPL_token* TMPL_tokenize(char* tmplstr, size_t strlen){
+struct TMPL_token*
+TMPL_tokenize(char* tmplstr, size_t strlen){
 	if(strlen == 0) return NULL;
 	struct TMPL_token* first;
 	char* textcursor = tmplstr;
 	size_t newlength;
 	enum TMPL_tagtype ttype;
 	ttype = starts_with_token(tmplstr+1,strlen);
-	//printf("First ttype is %d\n",(int)ttype);
 	if(ttype == tag_null){
 		first = scan_text(textcursor,strlen,&newlength);
 		first->type = tag_text;
@@ -310,18 +435,14 @@ struct TMPL_token* TMPL_tokenize(char* tmplstr, size_t strlen){
 		first = scan_tag(textcursor,strlen,&newlength);
 		first->type = ttype;
 	}
-	//printf("I got a first consumed length of %d\n",(int)newlength);
 	textcursor += newlength;
 	first->end = textcursor;
 	first->length = newlength;
 	strlen -= newlength;
 	struct TMPL_token* tokencursor = first;
 	struct TMPL_token* newnode;
-	//print_tokens(first);
 	while(*textcursor != '\0'){
-		//printf("Getting a new token... size was %d textcursor is %d\n", (int)newlength, (int)*textcursor);
 		ttype = starts_with_token(textcursor+1,strlen);
-		//printf("Loop ttype is %d\n",(int)ttype);
 		if(ttype == tag_null){
 			newnode = scan_text(textcursor,strlen,&newlength);
 			newnode->type = tag_text;
@@ -334,21 +455,18 @@ struct TMPL_token* TMPL_tokenize(char* tmplstr, size_t strlen){
 		strlen -= newlength;
 		tokencursor = newnode;
 	}
-	//printf("Returning from tokenize\n");
 	return first;
 }
-void print_varlist_helper(struct TMPL_varlist* vl, int indent);
-void print_varlist(struct TMPL_varlist* vl);
-
-struct TMPL_tagnode* parse(struct TMPL_token* head, struct TMPL_buf* errbuf);
 
-struct TMPL_tagnode* alloc_tagnode(){
+struct TMPL_tagnode*
+alloc_tagnode(){
 	struct TMPL_tagnode* t = malloc(sizeof(struct TMPL_tagnode));
 	return t;
 }
 
-//Finds a quoted string, allows for \"
-size_t get_quoted_string(char* start, size_t len){
+/*Finds a quoted string, allows for \"*/
+size_t
+get_quoted_string(char* start, size_t len){
 	size_t i;
 	int setup = 0;
 	for(i = 0; i < len; i++){
@@ -356,7 +474,7 @@ size_t get_quoted_string(char* start, size_t len){
 			setup = 1;
 		}else if(*(start+i) == '"'){
 			if(setup == 1){
-				//Do nothing, this is \"
+				/*Do nothing, this is \"*/
 			}else{
 				return i;
 			}
@@ -367,39 +485,33 @@ size_t get_quoted_string(char* start, size_t len){
 	return i;
 }
 
-struct TMPL_tagnode* parse_text(struct TMPL_token* head, struct TMPL_buf* errbuf){
-	//printf("Parsing text node\n");
+struct TMPL_tagnode*
+parse_text(struct TMPL_token* head, struct TMPL_buf* errbuf){
 	struct TMPL_tagnode* t = alloc_tagnode();
 	t->TMPL_tag.text.start = head->start;
 	t->TMPL_tag.text.len = head->length;
 	t->type = head->type;
-	//printf("About to call parse again\n");
 	struct TMPL_tagnode* n = parse(head->next, errbuf);
-	//printf("Parsed next\n");
 	t->next = n;
 	return t;
 }
 
-struct TMPL_tagnode* parse_else(struct TMPL_token* head, struct TMPL_buf* errbuf){
+struct TMPL_tagnode*
+parse_else(struct TMPL_token* head, struct TMPL_buf* errbuf){
 	struct TMPL_tagnode* branch = parse(head->next,errbuf);
 	return branch;
 }
 
-struct TMPL_tagnode* parse_elseif(struct TMPL_token* head, struct TMPL_buf* errbuf){
+struct TMPL_tagnode*
+parse_elseif(struct TMPL_token* head, struct TMPL_buf* errbuf){
 	struct TMPL_tagnode* t = alloc_tagnode();
-	//printf("Parsing elseif..., token was %s\n",head->start);
 	char* start_of_attribs = head->start + TAG_ELSEIF_LENGTH;
-	//printf("Start of attribs was %s\n",start_of_attribs);
 	int name_offset = kmp(start_of_attribs,head->length, ATTRIBUTE_VARNAME,ATTRIBUTE_VARNAME_LENGTH);
-	//printf("Found an elseif statement, offset is %d\n",name_offset);
 	char* start_of_name = start_of_attribs + name_offset + ATTRIBUTE_VARNAME_LENGTH;
-	//printf("Looking for name starting from %s\n",start_of_name);
 	size_t name_length = get_quoted_string(start_of_name,head->length);
-	//printf("Length of name was %d\n",(int)name_length);
 	char* name = (char*)malloc(sizeof(char)*name_length);
 	memcpy(name,start_of_name,name_length);
 	name[name_length] = '\0';
-	//printf("Makeing elseif with name: %s\n",name);
 	t->TMPL_tag.ifelse.varname = name;
 
 	int testval_offset = kmp(start_of_attribs,head->length, ATTRIBUTE_VALUE,ATTRIBUTE_VALUE_LENGTH);
@@ -428,7 +540,6 @@ struct TMPL_tagnode* parse_elseif(struct TMPL_token* head, struct TMPL_buf* errb
 		cursor = cursor->next;
 	}
 	if(fstart != NULL){
-		//printf("Found the fstart token to be %s\n",fstart->start);
 		if(fstart->type == tag_elseif){
 			t->TMPL_tag.ifelse.fbranch = parse_elseif(fstart,errbuf);
 		}else if(fstart->type == tag_else){
@@ -437,33 +548,28 @@ struct TMPL_tagnode* parse_elseif(struct TMPL_token* head, struct TMPL_buf* errb
 			t->TMPL_tag.ifelse.fbranch = parse(fstart,errbuf);
 		}
 	}else{
-		//printf("Did not find an fstart token\n");
 		t->TMPL_tag.ifelse.fbranch = NULL;
 	}
 
 	t->TMPL_tag.ifelse.tbranch = parse(head->next,errbuf);
-	t->next = NULL;//parse(cursor->next,errbuf);
+	t->next = NULL;
 	
 	t->type = tag_elseif;
-	//printf("Parsed elseif statement:\n");
-	//print_ast(t);
 	return t;
 
 }
 
-struct TMPL_tagnode* parse_if(struct TMPL_token* head, struct TMPL_buf* errbuf){
-	//printf("Parsing if...\n");
+struct TMPL_tagnode*
+parse_if(struct TMPL_token* head, struct TMPL_buf* errbuf){
 	struct TMPL_tagnode* t = alloc_tagnode();
 	char* start_of_attribs = head->start + TAG_IF_LENGTH;
 	/*Find the name of the varialbe*/	
 	int name_offset = kmp(start_of_attribs,head->length,ATTRIBUTE_VARNAME,ATTRIBUTE_VARNAME_LENGTH);
-	//printf("Found an if statement, name offset is %d\n",name_offset);
 	char* start_of_name = start_of_attribs + name_offset + ATTRIBUTE_VARNAME_LENGTH;
 	size_t name_length = get_quoted_string(start_of_name,head->length);
 	char* name = (char*)malloc(sizeof(char)*name_length);
 	memcpy(name,start_of_name,name_length);
 	name[name_length] = '\0';
-	//printf("Found if name:\"%s\"\n",name);
 	t->TMPL_tag.ifelse.varname = name;
 	/*Find the name to check against*/
 	int testval_offset = kmp(start_of_attribs,head->length, ATTRIBUTE_VALUE,ATTRIBUTE_VALUE_LENGTH);
@@ -472,7 +578,6 @@ struct TMPL_tagnode* parse_if(struct TMPL_token* head, struct TMPL_buf* errbuf){
 	char* value = (char*)malloc(sizeof(char)*value_length);
 	memcpy(value,start_of_value,value_length);
 	value[value_length] = '\0';
-	//printf("Found if value:\"%s\"\n",value);
 	t->TMPL_tag.ifelse.testval = value;
 	/*Find the true branch*/
 	struct TMPL_token* cursor = head->next;
@@ -494,43 +599,32 @@ struct TMPL_tagnode* parse_if(struct TMPL_token* head, struct TMPL_buf* errbuf){
 		cursor = cursor->next;
 	}
 	if(fstart != NULL){
-		//printf("Found the fstart token to be %s\n",fstart->start);
 		if(fstart->type == tag_elseif){
 			t->TMPL_tag.ifelse.fbranch = parse_elseif(fstart,errbuf);
 		}else if(fstart->type == tag_else){
-			//printf("Type was else, parsing...\n");
-			//printf("Tokens were:\n");
-			//print_tokens(fstart);
-			//struct TMPL_tagnode* tn = parse_else(fstart,errbuf);
-			//printf("Got tagnode back:\n");
-			//print_ast(tn);
 			t->TMPL_tag.ifelse.fbranch = parse_else(fstart,errbuf);
 		}else{
 			t->TMPL_tag.ifelse.fbranch = parse(fstart,errbuf);
 		}
 	}else{
-		//printf("Did not find an fstart token\n");
 		t->TMPL_tag.ifelse.fbranch = NULL;
 	}
 
 	t->TMPL_tag.ifelse.tbranch = parse(head->next,errbuf);
-	//Walk the tbranch and try to find if we have elseifs
+	/*Walk the tbranch and try to find if we have elseifs*/
 	t->next = parse(cursor->next,errbuf);
 	
 	t->type = tag_if;
-	//printf("Parsed if statement:\n");
-	//print_ast(t);
 	return t;
 }
 
 
-struct TMPL_tagnode* parse_loop(struct TMPL_token* head, struct TMPL_buf* errbuf){
-	//printf("Parsing loop that starts at %s\n",head->start);
+struct TMPL_tagnode*
+parse_loop(struct TMPL_token* head, struct TMPL_buf* errbuf){
 	struct TMPL_tagnode* t = alloc_tagnode();
 	char* loop_start = head->start + TAG_LOOP_LENGTH;
 	int loop_length = head->length - TAG_LOOP_LENGTH;
 	int name_offset = kmp(loop_start,loop_length, ATTRIBUTE_VARNAME, ATTRIBUTE_VARNAME_LENGTH);
-	//printf("In parse loop, name offset was %d\n",name_offset);
 	if(name_offset == -1 && DEBUGGING){
 		bputs(errbuf,"Parsing error: Could not find name attribute for loop near\n");
 		bputsn(errbuf,head->start, ERRBUF_HINTLEN);
@@ -538,13 +632,9 @@ struct TMPL_tagnode* parse_loop(struct TMPL_token* head, struct TMPL_buf* errbuf
 	}
 	if(name_offset >= 0){
 		char* start_of_name = loop_start + name_offset + ATTRIBUTE_VARNAME_LENGTH;
-		//printf("Start of name is at %s\n",start_of_name);
 		size_t name_size = get_quoted_string(start_of_name,head->length);
 		char* loopname = (char*)malloc(sizeof(char)*name_size);
 		loopname[name_size] = '\0';
-		//printf("Loop name size is %d\n", (int)name_size);
-		memcpy(loopname,start_of_name,name_size);
-		//printf("Got loop name %s\n",loopname);
 		t->TMPL_tag.loop.loopname = loopname;
 
 	}
@@ -552,8 +642,6 @@ struct TMPL_tagnode* parse_loop(struct TMPL_token* head, struct TMPL_buf* errbuf
 	int nest_level = 0;
 	struct TMPL_token* cursor = head->next;
 	while(cursor != NULL && (nest_level > 0 || cursor->type != tag_end)){
-		//printf("Trying to find end of loop, cursor is");
-		//print_tokens(cursor);
 		if(cursor == NULL){
 			bputs(errbuf,"Parse error : tried parsing loop and hit end of stream near\n");
 			bputsn(errbuf,head->start,ERRBUF_HINTLEN);
@@ -572,22 +660,18 @@ struct TMPL_tagnode* parse_loop(struct TMPL_token* head, struct TMPL_buf* errbuf
 		bputsn(errbuf,head->start,ERRBUF_HINTLEN);
 		return NULL;
 	}
-	//printf("Found end of loop near %20s\n",cursor->start);
 	t->TMPL_tag.loop.body = parse(head->next,errbuf);
 	t->next = parse(cursor->next,errbuf);
 	return t;
 }
 
-struct TMPL_tagnode* parse_variable(struct TMPL_token* head, struct TMPL_buf* errbuf){
-	//printf("Parsing variable\n");
+struct TMPL_tagnode*
+parse_variable(struct TMPL_token* head, struct TMPL_buf* errbuf){
 	struct TMPL_tagnode* t = alloc_tagnode();
 	char* start_of_attribs = head->start + TAG_VAR_LENGTH;
 	int attribs_length = head->length - TAG_VAR_LENGTH;
 	int in_name = kmp(start_of_attribs,attribs_length,ATTRIBUTE_VARNAME,ATTRIBUTE_VARNAME_LENGTH);
 	int in_default = kmp(start_of_attribs,attribs_length,ATTRIBUTE_DEFAULT,ATTRIBUTE_DEFAULT_LENGTH);
-	//printf("parse: start of attribs is %s\n",start_of_attribs);
-	//printf("parse: length of 1 was %d, length of 2 was %d\n",(int)attribs_length,(int)ATTRIBUTE_VARNAME_LENGTH);
-	//printf("While parseing variable, kmp search gave %d\n",in_name);
 	if(in_name == -1 && DEBUGGING){
 		char buf[ERR_MSG_LEN];
 		snprintf(buf,ERR_MSG_LEN,"Parsing error: Could not find name=\"name\" near %s\n",head->start);
@@ -601,7 +685,6 @@ struct TMPL_tagnode* parse_variable(struct TMPL_token* head, struct TMPL_buf* er
 		name[name_size] = '\0';
 		t->TMPL_tag.var.varname = name;
 		t->TMPL_tag.var.name_len = name_size;
-		//printf("Found a varname\n");
 	}
 	if(in_default >= 0){
 		char* start_of_default = start_of_attribs + in_default + ATTRIBUTE_DEFAULT_LENGTH;
@@ -611,41 +694,38 @@ struct TMPL_tagnode* parse_variable(struct TMPL_token* head, struct TMPL_buf* er
 		memcpy(def,start_of_default,default_size);
 		t->TMPL_tag.var.defaultval = def;
 		t->TMPL_tag.var.default_len = default_size;
-		//printf("Found a default\n");
 	}else{
 		t->TMPL_tag.var.default_len = 0;
 	}
 	t->type = tag_var;
 	t->next = parse(head->next,errbuf);
-	//printf("Returning %p From parse_variable\n",(void*)t);
-	//t->TMPL_tag.var.varname
 	return t;
 }
 
-struct TMPL_varlist* TMPL_alloc_varlist(){
+struct TMPL_varlist*
+TMPL_alloc_varlist(){
 	struct TMPL_varlist* ret = (struct TMPL_varlist*)malloc(sizeof(struct TMPL_varlist));
 	ret->map = hashmap_new();
 	return ret;
 }
 
 
-int TMPL_free_hashmapitems(any_t a, any_t b){
-	//printf("Freeing hashmap item at %p\n",(void*)b);
+int
+TMPL_free_hashmapitems(any_t a, any_t b){
 	struct TMPL_varitem* vi = (struct TMPL_varitem*)b;
 	TMPL_free_varitem(vi);
 	return MAP_OK;
 }
 
-void TMPL_free_varlist(struct TMPL_varlist* vl){
-	//printf("Freeing varlist:\n");
-	//print_varlist(vl);
+void
+TMPL_free_varlist(struct TMPL_varlist* vl){
 	hashmap_iterate(vl->map,TMPL_free_hashmapitems,NULL);
-	//printf("done interatively freeing\n");
 	hashmap_free(vl->map);
 	free(vl);
 }
 
-struct TMPL_loop* TMPL_alloc_loop(){
+struct TMPL_loop*
+TMPL_alloc_loop(){
 	struct TMPL_loop* ret = (struct TMPL_loop*)malloc(sizeof(struct TMPL_loop));
 	ret->loop_len = 0;
 	ret->varlist = NULL;
@@ -654,8 +734,8 @@ struct TMPL_loop* TMPL_alloc_loop(){
 	return ret;
 }
 
-void TMPL_free_loop(struct TMPL_loop* tl){
-	//printf("Freeing loop\n");
+void
+TMPL_free_loop(struct TMPL_loop* tl){
 	if(tl->next != NULL){
 		TMPL_free_loop(tl->next);
 	}
@@ -664,9 +744,7 @@ void TMPL_free_loop(struct TMPL_loop* tl){
 }
 
 void TMPL_add_varlist_to_loop(struct TMPL_loop* tl,struct TMPL_varlist* vl){
-	//printf("Adding varlist to loop\n");
-	//print_varlist(vl);
-	if(tl->loop_len == 0){// Add the first node
+	if(tl->loop_len == 0){/*Add the first node*/
 		tl->varlist = vl;
 		tl->tail = tl;
 		tl->loop_len++;
@@ -678,32 +756,27 @@ void TMPL_add_varlist_to_loop(struct TMPL_loop* tl,struct TMPL_varlist* vl){
 	}
 }
 
-void TMPL_add_loop_to_varlist(struct TMPL_varlist* vl, char* name, struct TMPL_loop* l){
-	//printf("Adding loop to varlist under \"%s\"\n",name);
+void
+TMPL_add_loop_to_varlist(struct TMPL_varlist* vl, char* name, struct TMPL_loop* l){
 	struct TMPL_varitem* vi = TMPL_alloc_varitem();
 	vi->type = vartype_loop;
 	vi->item.l = l;
 	int err = hashmap_put(vl->map,name,vi);
 	if(err != MAP_OK){
-		//printf("Failed to add loop to varlist:%d\n",err);
 	}
 	struct TMPL_varitem* back;
 	hashmap_get(vl->map,name,(void**)&back);
-	//printf("Trying to get %s back out: %p\n",name,(void*)back);
-	//printf("Varlist is now:\n");
-	//print_varlist(vl);
 }
 
 
 
-//Parses tokens into a syntax tree
-struct TMPL_tagnode* parse(struct TMPL_token* head, struct TMPL_buf* errbuf){
+/*Parses tokens into a syntax tree*/
+struct TMPL_tagnode*
+parse(struct TMPL_token* head, struct TMPL_buf* errbuf){
 	struct TMPL_tagnode* root;
 	if(head == NULL){
-		//printf("Asked to parse null");
 		return NULL;
 	}
-	//printf("In parse, type is %d\n",(int)head->type);
 	switch(head->type){
 		case tag_text:
 			root = parse_text(head,errbuf);
@@ -716,75 +789,56 @@ struct TMPL_tagnode* parse(struct TMPL_token* head, struct TMPL_buf* errbuf){
 			break;
 		case tag_end:
 			root = NULL;
-			//root = prase(head->next, errbuf);
 			break;
 		case tag_if:
 			root = parse_if(head,errbuf);
-			//printf("Returned from parsing if\n");
 			break;
 		case tag_elseif:
 			root = NULL;
-			//root = parse_elseif(head,errbuf);
-			//printf("Returned from parsing elseif\n");
 			break;
 		case tag_else:
 			root = NULL;
-			//root = parse_else(head,errbuf);
 			break;
 		default:
-			//printf("Exiting parse early\n");
 			exit(-1);
 			break;
 	}
-	//size_t dummy;
-	//printf("Errbuf was %s\n",bstringify(errbuf,&dummy));
 	if(errbuf->total_len > 0){
-		//printf("FAiled to parse\n");
 		return NULL;
 	}
 	return root;
 }
 
-struct TMPL_templates* alloc_templates(){
+struct TMPL_templates*
+alloc_templates(){
 	struct TMPL_templates* t = malloc(sizeof(struct TMPL_templates));
 	return t;
 }
 
-struct TMPL_templates* compile(char* tmplstr){
+struct TMPL_templates*
+compile(char* tmplstr){
 	size_t slen = strlen(tmplstr);
 	struct TMPL_templates* ret = alloc_templates();
 	ret->out = alloc_tmpl_buf();
 	ret->errout = alloc_tmpl_buf();
 	struct TMPL_token* tokens = TMPL_tokenize(tmplstr,slen);
-	//printf("Tokenized %p\n",(void*)tokens);
-	//print_tokens(tokens);
 	struct TMPL_tagnode* ast = parse(tokens,ret->errout);
-	//printf("Ast was:\n");
-	//print_ast(ast);
 	if(ast == NULL){
-		//printf("ast was null");
 	}else{
 		ret->roottag = ast;
 	}
-	//printf("ret roottag is %p\n",(void*)ret->roottag);
 	return ret;
 }
 
-int render_any(struct TMPL_templates* t, struct TMPL_tagnode* node, struct TMPL_varlist* varlist);
 
-int render_variable(struct TMPL_templates* t, struct TMPL_tagnode* node, struct TMPL_varlist* varlist){
-	//printf("Rendering variable...\n");
+int
+render_variable(struct TMPL_templates* t, struct TMPL_tagnode* node, struct TMPL_varlist* varlist){
 	struct TMPL_varitem* vi;
 	char* varname = node->TMPL_tag.var.varname;
-	//printf("Looking for var name %s in\n",varname);
-	//print_varlist(varlist);
 	int err = hashmap_get(varlist->map,varname,(void**)&vi);
-	//printf("Err is %d\n",err);
 	if(err == MAP_OK){
-		//printf("Rendering val: %s\n", vi->item.s);
 		bputs(t->out,vi->item.s);
 	}else if(err == MAP_MISSING){
-		//printf("Missing var named %s\n",varname);
 		size_t has_default = node->TMPL_tag.var.default_len;
 		if(has_default){
 			bputs(t->out,node->TMPL_tag.var.defaultval);
@@ -793,13 +847,13 @@ int render_variable(struct TMPL_templates* t, struct TMPL_tagnode* node, struct
 			return -1;
 		}
 	}else{
-		//printf("Failed to put in var\n");
 		return -1;
 	}
 	return 0;
 }
 
-int render_text(struct TMPL_templates* t, struct TMPL_tagnode* node, struct TMPL_varlist* varlist){
+int
+render_text(struct TMPL_templates* t, struct TMPL_tagnode* node, struct TMPL_varlist* varlist){
 	struct TMPL_buf* buf = t->out;
 	char* text = (char*)node->TMPL_tag.text.start;
 	size_t length = node->TMPL_tag.text.len;
@@ -807,7 +861,8 @@ int render_text(struct TMPL_templates* t, struct TMPL_tagnode* node, struct TMPL
 	return 0;
 }
 
-int print_pair(any_t indent, any_t b){
+int
+print_pair(any_t indent, any_t b){
 	struct TMPL_varitem* vi = (struct TMPL_varitem*)b;
 	int* ip = (int*)indent;
 	int ind = *ip;
@@ -828,37 +883,31 @@ int print_pair(any_t indent, any_t b){
 	return MAP_OK;
 }
 
-void print_varlist_helper(struct TMPL_varlist* vl, int indent){
+void
+print_varlist_helper(struct TMPL_varlist* vl, int indent){
 	hashmap_iterate(vl->map, print_pair,&indent);
 }
 
 
-void print_varlist(struct TMPL_varlist* vl){
+void
+print_varlist(struct TMPL_varlist* vl){
 	print_varlist_helper(vl,0);
 }
 
-int render_if(struct TMPL_templates* t, struct TMPL_tagnode* node, struct TMPL_varlist* varlist){
-	//printf("Rendering if...\n");
-	//printf("Node %p tag %p\n",(void*)node,(void*)node->TMPL_tag.ifelse.varname);
+int
+render_if(struct TMPL_templates* t, struct TMPL_tagnode* node, struct TMPL_varlist* varlist){
 	char* varname = node->TMPL_tag.ifelse.varname;
-	//printf("Got varname: %s\n",varname);
 	char* testval = node->TMPL_tag.ifelse.testval;
-	//printf("Got varname %s and testval %s\n",varname,testval);
 	struct TMPL_varitem* vi;
-	//printf("About to hashmap get\n");
 	int err = hashmap_get(varlist->map,varname,(void**)&vi);
-	//printf("Found variable with key \"%s\" : \"%s\"\n",varname,vi->item.s);
 	struct TMPL_tagnode* cursor;
 	if(err == MAP_OK && strcmp(vi->item.s,testval) == 0){
-		//printf("Rendering true branch\n");
 		cursor = node->TMPL_tag.ifelse.tbranch;
 		while(cursor != NULL){
 			render_any(t,cursor,varlist);
 			cursor = cursor->next;
 		}
 	}else if(node->TMPL_tag.ifelse.fbranch != NULL){
-		//printf("Rendering false branch\n");
-		//render_any(t,node->TMPL_tag.ifelse.fbranch,varlist);
 		cursor = node->TMPL_tag.ifelse.fbranch;
 		while(cursor != NULL){
 			render_any(t,cursor,varlist);
@@ -869,121 +918,72 @@ int render_if(struct TMPL_templates* t, struct TMPL_tagnode* node, struct TMPL_v
 }
 
 /*Exactly the same thing as if*/
-int render_elseif(struct TMPL_templates* t, struct TMPL_tagnode* node, struct TMPL_varlist* varlist){
+int
+render_elseif(struct TMPL_templates* t, struct TMPL_tagnode* node, struct TMPL_varlist* varlist){
 	return render_if(t,node,varlist);
-	/*
-	char* varname = node->TMPL_tag.ifelse.varname;
-	char* testval = node->TMPL_tag.ifelse.testval;
-	struct TMPL_varitem* vi;
-	int err = hashmap_get(varlist->map,varname,(void**)&vi);
-	//printf("Rendering elseif ast:\n");
-	//print_ast(node);
-	struct TMPL_tagnode* cursor;
-	if(err == MAP_OK && strcmp(vi->item.s, testval) == 0){
-		//printf("Rendering true branch\n");
-		cursor = node->TMPL_tag.ifelse.tbranch;
-		while(cursor != NULL){
-			render_any(t,cursor,varlist);
-			cursor = cursor->next;
-		}
-	}else if(node->TMPL_tag.ifelse.fbranch != NULL){
-		//printf("Rendering false branch\n");
-		cursor = node->TMPL_tag.ifelse.fbranch;
-		while(cursor != NULL){
-			render_any(t,cursor,varlist);
-			cursor = cursor->next;
-		}
-	}
-	return 0;
-	*/
 }
-void TMPL_render_helper(struct TMPL_templates* t, struct TMPL_varlist* varlist);
 
-int render_loop(struct TMPL_templates* t, struct TMPL_tagnode* node, struct TMPL_varlist* varlist){
+int
+render_loop(struct TMPL_templates* t, struct TMPL_tagnode* node, struct TMPL_varlist* varlist){
 	char* loopname = node->TMPL_tag.loop.loopname;
 	struct TMPL_varitem* loop;
-	//printf("Attempting to render loop:\n");
-	//print_ast(node);
-	//printf("With varlist:\n");
-	//print_varlist(varlist);
-	//printf("Looking for loop name %s\n", loopname);
 	int err = hashmap_get(varlist->map,loopname,(void*)&loop);
 	if(err != MAP_OK){
-		//printf("Failed to get loop struct, %d\n",err);
 		return -1;
 	}
-	//printf("Got loop struct %p\n",(void*)loop);
-	//printf("First varlist is\n");
-	//print_varlist(loop->item.l->varlist);
 	struct TMPL_templates* nt = (struct TMPL_templates*)malloc(sizeof(struct TMPL_templates));
 	nt->out = t->out;
 	nt->errout = t->errout;
 	nt->roottag = node->TMPL_tag.loop.body;
 	struct TMPL_loop* cursor;
 	for(cursor = loop->item.l; cursor != NULL; cursor = cursor->next){
-		//printf("Rendering loop.This varlist is\n");
-		//print_varlist(cursor->varlist);
-		//int err = render_any(t,node->TMPL_tag.loop.body,cursor->varlist);
 		if(err != 0){
-			//printf("Failed to render loop\n");
 		}
 		TMPL_render_helper(nt,cursor->varlist);
 	}
-	//struct TMPL_buf* buf = t->out;
-	//printf("Done rendering loop\n");
 	free(nt);
 	return 0;
 }
 
-int render_any(struct TMPL_templates* t, struct TMPL_tagnode* node, struct TMPL_varlist* varlist){
+int
+render_any(struct TMPL_templates* t, struct TMPL_tagnode* node, struct TMPL_varlist* varlist){
 	/*Interpret the template*/
 	int err;
 	switch(node->type){
 		case tag_text:
-			//printf("Rendering text\n");
 			err = render_text(t,node,varlist);
 			if(err < 0){
-				//printf("Failed to render text\n");
 			}
-			//printf("Done rendering text\n");
 			break;
 		case tag_var:
-			//printf("Rendering var\n");
 			err = render_variable(t,node,varlist);
 			if(err < 0){
-				//printf("Failed to render variable\n");
 			}
 			break;
 		case tag_loop:
-			//printf("Rendering loop\n");
 			err = render_loop(t,node,varlist);
 			if(err < 0){
-				//printf("Failed to render loop\n");
 			}
 			break;
 		case tag_if:
-			//printf("Rendering if\n");
 			err = render_if(t,node,varlist);
 			if(err < 0){
-				//printf("Failed to render if\n");
 			}
 			break;
 		case tag_elseif:
-			//printf("Rendering elseif\n");
 			err = render_elseif(t,node,varlist);
 			if(err < 0){
-				//printf("Failed to render elseif\n");
 			}
 			break;
 		default:
-			//printf("Rendering default %d\n",(int)node->type);
 			exit(-1);
 			break;
 	}
 	return err;
 }
 
-void TMPL_render_helper(struct TMPL_templates* t, struct TMPL_varlist* varlist){
+void
+TMPL_render_helper(struct TMPL_templates* t, struct TMPL_varlist* varlist){
 	struct TMPL_tagnode* cursor = t->roottag;
 	while(cursor != NULL){
 		render_any(t,cursor,varlist);
@@ -992,7 +992,8 @@ void TMPL_render_helper(struct TMPL_templates* t, struct TMPL_varlist* varlist){
 
 }
 
-char* TMPL_render(struct TMPL_templates* t, struct TMPL_varlist* varlist){
+char*
+TMPL_render(struct TMPL_templates* t, struct TMPL_varlist* varlist){
 	if(t->out != NULL){
 		free_tmpl_buf(t->out);
 	}
@@ -1003,9 +1004,9 @@ char* TMPL_render(struct TMPL_templates* t, struct TMPL_varlist* varlist){
 	return ret;
 }
 
-struct TMPL_templates* TMPL_alloc_template(char* tmplstr){
+struct TMPL_templates*
+TMPL_alloc_template(char* tmplstr){
 	struct TMPL_templates* n = compile(tmplstr);
-	////printf("After returning from compile, rottag is %p\n",(void*)n->roottag);
 
 	if(n != NULL){
 		return n;
@@ -1015,17 +1016,16 @@ struct TMPL_templates* TMPL_alloc_template(char* tmplstr){
 	}
 }
 
-void TMPL_free_template(struct TMPL_templates* t){
+void
+TMPL_free_template(struct TMPL_templates* t){
 	free_tmpl_buf(t->out);
 	free_tmpl_buf(t->errout);
 	TMPL_free_tagnode(t->roottag);
 	free(t);
-	////printf("Freed tagnodes\n");
 }
 
-void TMPL_free_tagnode(struct TMPL_tagnode* tn){
-	//printf("Freeing tagnode:\n");
-	//print_ast(tn);
+void
+TMPL_free_tagnode(struct TMPL_tagnode* tn){
 	switch(tn->type){
 		case tag_text:
 			break;
@@ -1060,7 +1060,8 @@ void TMPL_free_tagnode(struct TMPL_tagnode* tn){
 	free(tn);
 }
 
-char* TMPL_get_error(struct TMPL_templates* t){
+char*
+TMPL_get_error(struct TMPL_templates* t){
 	size_t dummy;
 	return bstringify(t->errout,&dummy);
 }