Even more work.

1 files changed, 40 insertions, 89 deletions

diff --git a/parse.c b/parse.c
index b151933a..4378685a 100644
--- a/parse.c
+++ b/parse.c
@@ -8,17 +8,7 @@
 #include "vcal.h"
 
 #include "err.h"
-
-// #define TYPE vcomponent
-// #include "linked_list.inc.h"
-// #undef TYPE
-
-// #define T strbuf
-// #define V strbuf
 #include "pair.h"
-// #include "pair.inc.h"
-// #undef T
-// #undef V
 
 /*
  * name *(";" param) ":" value CRLF
@@ -27,11 +17,10 @@ int parse_file(char* filename, FILE* f, vcomponent* root) {
 	part_context p_ctx = p_key;
 
 	parse_ctx ctx(filename);
-	// PUSH(LLIST(vcomponent))(&ctx.comp_stack, root);
 	ctx.comp_stack.push(root);
 
-	content_line cline;
-	// SNEW(content_line, cline);
+	strbuf key;
+	param_set* ps;
 
 	char c;
 	while ( (c = fgetc(f)) != EOF) {
@@ -42,15 +31,10 @@ int parse_file(char* filename, FILE* f, vcomponent* root) {
 			if (fold(f, &ctx, c) > 0) {
 				/* Actuall end of line, handle value */
 
-				strbuf* target = CLINE_CUR_VAL(&cline);
-
-				// DEEP_COPY(strbuf)(target, &ctx.str);
-				*target = ctx.str;
-				strbuf_cap(target);
+				strbuf_cap(&ctx.str);
+				handle_kv(&key, &ctx);
 				strbuf_soft_reset(&ctx.str);
 
-				handle_kv(&cline, &ctx);
-
 				p_ctx = p_key;
 			} /* Else continue on current line */
 
@@ -97,16 +81,11 @@ int parse_file(char* filename, FILE* f, vcomponent* root) {
 
 		/* Border between param {key, value} */
 		} else if (p_ctx == p_param_name && c == '=') {
-			auto params = CLINE_CUR_PARAMS(&cline);
+			strbuf_cap(&ctx.str);
 
-			// NEW(param_set, ps);
-			auto ps = new param_set;
-			// DEEP_COPY(strbuf)(&ps->key, &ctx.str);
+			ps = new param_set;
 			*ps->key = ctx.str;
-			strbuf_cap(ps->key);
 			strbuf_soft_reset(&ctx.str);
-			// PUSH(LLIST(param_set))(params, ps);
-			params->push(ps);
 
 			p_ctx = p_param_value;
 
@@ -118,39 +97,29 @@ int parse_file(char* filename, FILE* f, vcomponent* root) {
 		 * 4)   ,,   param,    ,,    value
 		 */
 		} else if ((p_ctx == p_key || p_ctx == p_param_value) && (c == ':' || c == ';')) {
+			/* We have the end of the initial key, or the end of a
+			 * parameter value */ 
+			strbuf_cap(&ctx.str);
 
 			if (p_ctx == p_param_value) {
 				/* push kv pair */
-
-				// NEW(strbuf, s);
-				auto s = new strbuf;
-				*s = ctx.str;
-
-				// DEEP_COPY(strbuf)(s, &ctx.str);
-				strbuf_cap(s);
+				ps->val->push(new strbuf(ctx.str));
 				strbuf_soft_reset(&ctx.str);
 
-				CLINE_CUR_PARAMS(&cline)->cur->value->val->push(s);
-				// PUSH(LLIST(strbuf))(ls, s);
-
 			}
 
 			if (p_ctx == p_key) {
-				// DEEP_COPY(strbuf)(&cline.key, &ctx.str);
-				*cline.key = ctx.str;
-				strbuf_cap(cline.key);
+				strbuf_cap(&ctx.str);
+				key = ctx.str;
 				strbuf_soft_reset(&ctx.str);
-
-				// NEW(content_set, p);
-				auto p = new content_set;
-				// PUSH(LLIST(content_set))(&cline.val, p);
-				cline.val->push(p);
 			}
 
 			if      (c == ':') p_ctx = p_value;
 			else if (c == ';') p_ctx = p_param_name;
 
 		} else {
+			/* Regular character, append it to the current read
+			 * buffer */
 			strbuf_append(&ctx.str, c);
 
 			++ctx.column;
@@ -169,15 +138,18 @@ int parse_file(char* filename, FILE* f, vcomponent* root) {
 		 * the end here.
 		 */
 
+		/*
 		strbuf* target = CLINE_CUR_VAL(&cline);
 		*target = ctx.str;
-		strbuf_cap(target);
+		*/
+
+		strbuf_cap(&ctx.str);
+		handle_kv(&key, &ctx);
 		strbuf_soft_reset(&ctx.str);
 
 		++ctx.line;
 		ctx.column = 0;
 
-		handle_kv(&cline, &ctx);
 
 	}
 
@@ -196,68 +168,57 @@ int parse_file(char* filename, FILE* f, vcomponent* root) {
 }
 
 int handle_kv (
-	content_line* cline,
+	strbuf* key,
+	// content_line* cline,
 	parse_ctx* ctx
 	) {
 
-	if (strbuf_c(cline->key, "BEGIN")) {
+	if (*key == "BEGIN") {
 		/* should be one of:
 		 * VCALENDAR, VEVENT, VALARM, VTODO, VTIMEZONE,
 		 * and possibly some others I forget.
 		 */
 
-		// NEW(strbuf, s);
-		auto s = new strbuf;
-		// strbuf* type = CLINE_CUR_VAL(cline);
-		// DEEP_COPY(strbuf)(s, type);
-		*s = *CLINE_CUR_VAL(cline);
-		// PUSH(LLIST(strbuf))(&ctx->key_stack, s);
-		ctx->key_stack.push(s);
+		ctx->key_stack.push(key);
 
-		// RESET(LLIST(content_set))(&cline->val);
-		cline->val->reset();
-
-		auto e = new vcomponent(s->mem, ctx->filename);
-		// e->parent = PEEK(LLIST(vcomponent))(&ctx->comp_stack);
+		auto e = new vcomponent(ctx->str.mem, ctx->filename);
 		e->parent = ctx->comp_stack.peek();
-		//PUSH(LLIST(vcomponent))(&ctx->comp_stack, e);
 		ctx->comp_stack.push(e);
 
-	} else if (strbuf_c(cline->key, "END")) {
+	/* A block is ending */
+	} else if (*key == "END") {
 		//strbuf* s = POP(LLIST(strbuf))(&ctx->key_stack);
+		/* Fetch what we are supposed to end */ 
 		strbuf* s = ctx->key_stack.pop();
-		if (strbuf_cmp(s, CLINE_CUR_VAL(cline)) != 0) {
+		/* Error if we got something else */
+		if (ctx->str != *s) {
 			// ERR_P(ctx, "Expected END:%s, got END:%s.\n%s line",
 			// 		s->mem,
 			// 		CLINE_CUR_VAL(cline)->mem,
 			// 		PEEK(LLIST(vcomponent))(&ctx->comp_stack)->filename);
 			// PUSH(LLIST(strbuf))(&ctx->key_stack, s);
+			/* put value back on stack */
 			ctx->key_stack.push(s);
 			return -1;
 
+		/* We got a propper end, make the current vcomponent a child
+		 * to the vcomponent under it on the stack.*/
 		} else {
-			delete s;
-			// FFREE(strbuf, s);
+			/* free the key string */
+			// delete s;
+
 			/* Received propper end, push cur into parent */
-			// vcomponent* cur = POP(LLIST(vcomponent))(&ctx->comp_stack);
 			vcomponent* cur = ctx->comp_stack.pop();
 
 			// TODO should self instead be done at creation time?
 			PUSH(vcomponent)(ctx->comp_stack.peek(), cur);
 		}
+
+	/* Neither BEGIN nor END, so a regular KV pair */
 	} else {
-		//NEW(content_line, c);
-		content_line* c = new content_line(*cline);
-		// DEEP_COPY(content_line)(c, cline);
-
-		// PUSH(TRIE(content_line))(
-		// 		&PEEK(LLIST(vcomponent))(&ctx->comp_stack)->clines,
-		// 		c->key.mem, c);
-		// (PEEK(LLIST(vcomponent))(&ctx->comp_stack)->clines).push(c->key.mem, c);
-		ctx->comp_stack.peek()->clines.push(c->key->mem, c);
-
-		//RESET(LLIST(content_set))(&cline->val);
-		cline->val->reset();
+		strbuf* val = &ctx->str;
+		vcomponent* cur_comp = ctx->comp_stack.peek();
+		cur_comp->push_kv (key, val);
 	}
 
 	return 0;
@@ -297,10 +258,7 @@ int fold(FILE* f, parse_ctx* ctx, char c) {
 }
 
 
-//INIT_F(parse_ctx, char* filename) {
 parse_ctx::parse_ctx (const char* filename) {
-	// INIT(LLIST(strbuf), &this->key_stack);
-	// INIT(LLIST(vcomponent), &this->comp_stack);
 	this->filename = (char*) calloc(sizeof(*filename), strlen(filename) + 1);
 	strcpy(this->filename, filename);
 
@@ -309,18 +267,11 @@ parse_ctx::parse_ctx (const char* filename) {
 
 	this->pline   = 1;
 	this->pcolumn = 1;
-
-	// INIT(strbuf, &this->str);
 }
 
-// FREE_F(parse_ctx) {
 parse_ctx::~parse_ctx () {
-
-	// FREE(LLIST(strbuf))(&this->key_stack);
-	// FREE(LLIST(vcomponent))(&this->comp_stack);
 	free(this->filename);
 
 	this->line = 0;
 	this->column = 0;
-	// FREE(strbuf)(&this->str);
 }