Simplify stack management by popping in bulk at higher levels

Since all memory used by the reader is POD in the stack, there is no benefit to
forcing code to explicitly pop everything pushed to the stack, since any
function can record an offset and pop back down to it regardless of what its
callers pushed if it knows that it does not need those items.

1 files changed, 31 insertions, 54 deletions

diff --git a/src/n3.c b/src/n3.c
index 190d7239..1b2c5a06 100644
--- a/src/n3.c
+++ b/src/n3.c
@@ -680,7 +680,6 @@ read_IRIREF(SerdReader* reader, SerdNode** dest)
 	*dest = push_node(reader, SERD_URI, "", 0);
 
 	if (!fancy_syntax(reader) && read_IRIREF_scheme(reader, *dest)) {
-		*dest = pop_node(reader, *dest);
 		return r_err(reader, SERD_ERR_BAD_SYNTAX, "expected IRI scheme\n");
 	}
 
@@ -690,20 +689,17 @@ read_IRIREF(SerdReader* reader, SerdNode** dest)
 		const int c = eat_byte_safe(reader, peek_byte(reader));
 		switch (c) {
 		case '"': case '<': case '^': case '`': case '{': case '|': case '}':
-			*dest = pop_node(reader, *dest);
 			return r_err(reader, SERD_ERR_BAD_SYNTAX,
 			             "invalid IRI character `%c'\n", c);
 		case '>':
 			return SERD_SUCCESS;
 		case '\\':
 			if (read_UCHAR(reader, *dest, &code)) {
-				*dest = pop_node(reader, *dest);
 				return r_err(reader, SERD_ERR_BAD_SYNTAX,
 				             "invalid IRI escape\n");
 			}
 			switch (code) {
 			case 0: case ' ': case '<': case '>':
-				*dest = pop_node(reader, *dest);
 				return r_err(reader, SERD_ERR_BAD_SYNTAX,
 				             "invalid escaped IRI character U+%04X\n", code);
 			default:
@@ -722,7 +718,6 @@ read_IRIREF(SerdReader* reader, SerdNode** dest)
 					      (unsigned)c);
 				}
 				if (reader->strict) {
-					*dest = pop_node(reader, *dest);
 					return SERD_ERR_BAD_SYNTAX;
 				}
 				st = SERD_FAILURE;
@@ -731,14 +726,12 @@ read_IRIREF(SerdReader* reader, SerdNode** dest)
 				push_byte(reader, *dest, c);
 			} else if (read_utf8_character(reader, *dest, (uint8_t)c)) {
 				if (reader->strict) {
-					*dest = pop_node(reader, *dest);
 					return SERD_ERR_BAD_SYNTAX;
 				}
 			}
 		}
 	}
 
-	*dest = pop_node(reader, *dest);
 	return st;
 }
 
@@ -871,7 +864,7 @@ read_literal(SerdReader*    reader,
 
 	SerdStatus st = read_String(reader, *dest, flags);
 	if (st) {
-		*dest = pop_node(reader, *dest);
+		*dest = NULL;
 		return st;
 	}
 
@@ -880,9 +873,6 @@ read_literal(SerdReader*    reader,
 		eat_byte_safe(reader, '@');
 		*flags |= SERD_HAS_LANGUAGE;
 		if ((st = read_LANGTAG(reader, lang))) {
-			*datatype = pop_node(reader, *datatype);
-			*lang     = pop_node(reader, *lang);
-			*dest     = pop_node(reader, *dest);
 			return r_err(reader, st, "bad literal\n");
 		}
 		break;
@@ -891,9 +881,6 @@ read_literal(SerdReader*    reader,
 		eat_byte_check(reader, '^');
 		*flags |= SERD_HAS_DATATYPE;
 		if ((st = read_iri(reader, datatype, ate_dot))) {
-			*datatype = pop_node(reader, *datatype);
-			*lang     = pop_node(reader, *lang);
-			*dest     = pop_node(reader, *dest);
 			return r_err(reader, st, "bad literal\n");
 		}
 		break;
@@ -904,6 +891,7 @@ read_literal(SerdReader*    reader,
 static SerdStatus
 read_verb(SerdReader* reader, SerdNode** dest)
 {
+	const size_t orig_stack_size = reader->stack.size;
 	if (peek_byte(reader) == '<') {
 		return read_IRIREF(reader, dest);
 	}
@@ -922,13 +910,13 @@ read_verb(SerdReader* reader, SerdNode** dest)
 	if (!st && node->n_bytes == 1 &&
 	    serd_node_string(node)[0] == 'a' &&
 	    next != ':' && !is_PN_CHARS_BASE((uint32_t)next)) {
-		pop_node(reader, *dest);
+		serd_stack_pop_to(&reader->stack, orig_stack_size);
 		*dest = push_node(reader, SERD_URI, NS_RDF "type", 47);
 		return SERD_SUCCESS;
 	} else if (st > SERD_FAILURE ||
 	           read_PrefixedName(reader, *dest, false, &ate_dot) ||
 	           ate_dot) {
-		*dest = pop_node(reader, *dest);
+		*dest = NULL;
 		return r_err(reader, SERD_ERR_BAD_SYNTAX, "bad verb\n");
 	}
 
@@ -951,7 +939,6 @@ read_BLANK_NODE_LABEL(SerdReader* reader, SerdNode** dest, bool* ate_dot)
 	if (is_digit(c) || c == '_') {
 		push_byte(reader, n, eat_byte_safe(reader, c));
 	} else if (read_PN_CHARS(reader, n)) {
-		*dest = pop_node(reader, n);
 		return r_err(reader, SERD_ERR_BAD_SYNTAX, "invalid name start\n");
 	}
 
@@ -978,7 +965,6 @@ read_BLANK_NODE_LABEL(SerdReader* reader, SerdNode** dest, bool* ate_dot)
 				reader->seen_genid = true;
 			} else if (reader->seen_genid &&
 			           buf[reader->bprefix_len] == 'B') {
-				*dest = pop_node(reader, n);
 				return r_err(
 					reader, SERD_ERR_ID_CLASH,
 					"found both `b' and `B' blank IDs, prefix required\n");
@@ -1061,9 +1047,7 @@ read_object(SerdReader* reader, ReadContext* ctx, bool emit, bool* ate_dot)
 	static const char* const XSD_BOOLEAN     = NS_XSD "boolean";
 	static const size_t      XSD_BOOLEAN_LEN = 40;
 
-#ifndef NDEBUG
 	const size_t orig_stack_size = reader->stack.size;
-#endif
 
 	SerdStatus ret = SERD_FAILURE;
 
@@ -1129,7 +1113,6 @@ read_object(SerdReader* reader, ReadContext* ctx, bool emit, bool* ate_dot)
 		} else {
 			if ((ret = read_PrefixedName(reader, o, false, ate_dot))) {
 				ret = ret > SERD_FAILURE ? ret : SERD_ERR_BAD_SYNTAX;
-				pop_node(reader, o);
 				return r_err(reader, ret, "expected prefixed name\n");
 			}
 		}
@@ -1148,9 +1131,7 @@ read_object(SerdReader* reader, ReadContext* ctx, bool emit, bool* ate_dot)
 		return SERD_SUCCESS;
 	}
 
-	pop_node(reader, lang);
-	pop_node(reader, datatype);
-	pop_node(reader, o);
+	serd_stack_pop_to(&reader->stack, orig_stack_size);
 #ifndef NDEBUG
 	assert(reader->stack.size == orig_stack_size);
 #endif
@@ -1176,12 +1157,14 @@ read_objectList(SerdReader* reader, ReadContext ctx, bool* ate_dot)
 static SerdStatus
 read_predicateObjectList(SerdReader* reader, ReadContext ctx, bool* ate_dot)
 {
+	const size_t orig_stack_size = reader->stack.size;
+
 	SerdStatus st = SERD_SUCCESS;
 	while (!(st = read_verb(reader, &ctx.predicate)) &&
 	       read_ws_star(reader) &&
 	       !(st = read_objectList(reader, ctx, ate_dot))) {
-		ctx.predicate = pop_node(reader, ctx.predicate);
 		if (*ate_dot) {
+			serd_stack_pop_to(&reader->stack, orig_stack_size);
 			return SERD_SUCCESS;
 		}
 
@@ -1191,9 +1174,11 @@ read_predicateObjectList(SerdReader* reader, ReadContext ctx, bool* ate_dot)
 			read_ws_star(reader);
 			switch (c = peek_byte(reader)) {
 			case EOF:
+				serd_stack_pop_to(&reader->stack, orig_stack_size);
 				return r_err(reader, SERD_ERR_BAD_SYNTAX,
 				             "unexpected end of file\n");
 			case '.': case ']': case '}':
+				serd_stack_pop_to(&reader->stack, orig_stack_size);
 				return SERD_SUCCESS;
 			case ';':
 				eat_byte_safe(reader, c);
@@ -1202,23 +1187,19 @@ read_predicateObjectList(SerdReader* reader, ReadContext ctx, bool* ate_dot)
 		} while (c == ';');
 
 		if (!ate_semi) {
+			serd_stack_pop_to(&reader->stack, orig_stack_size);
 			return r_err(reader, SERD_ERR_BAD_SYNTAX, "missing ';' or '.'\n");
 		}
 	}
 
-	ctx.predicate = pop_node(reader, ctx.predicate);
+	serd_stack_pop_to(&reader->stack, orig_stack_size);
+	ctx.predicate = 0;
 	return st;
 }
 
 static SerdStatus
-end_collection(SerdReader* reader,
-               ReadContext ctx,
-               SerdNode*   n1,
-               SerdNode*   n2,
-               SerdStatus  st)
+end_collection(SerdReader* reader, ReadContext ctx, SerdStatus st)
 {
-	pop_node(reader, n2);
-	pop_node(reader, n1);
 	*ctx.flags &= ~(unsigned)SERD_LIST_CONT;
 	if (!st) {
 		return (eat_byte_check(reader, ')') == ')') ? SERD_SUCCESS
@@ -1244,13 +1225,12 @@ read_collection(SerdReader* reader, ReadContext ctx, SerdNode** dest)
 	}
 
 	if (end) {
-		return end_collection(reader, ctx, 0, 0, st);
+		return end_collection(reader, ctx, st);
 	}
 
 	/* The order of node allocation here is necessarily not in stack order,
 	   so we create two nodes and recycle them throughout. */
 	SerdNode* n1   = push_node_padded(reader, genid_size(reader), SERD_BLANK, "", 0);
-	SerdNode* n2   = 0;
 	SerdNode* node = n1;
 	SerdNode* rest = 0;
 
@@ -1264,14 +1244,14 @@ read_collection(SerdReader* reader, ReadContext ctx, SerdNode** dest)
 		ctx.predicate = reader->rdf_first;
 		bool ate_dot = false;
 		if ((st = read_object(reader, &ctx, true, &ate_dot)) || ate_dot) {
-			return end_collection(reader, ctx, n1, n2, st);
+			return end_collection(reader, ctx, st);
 		}
 
 		if (!(end = peek_delim(reader, ')'))) {
 			/* Give rest a new ID.  Done as late as possible to ensure it is
 			   used and > IDs generated by read_object above. */
 			if (!rest) {
-				rest = n2 = blank_id(reader);  // First pass, push
+				rest = blank_id(reader);  // First pass, push
 			} else {
 				set_blank_id(reader, rest, genid_size(reader));
 			}
@@ -1287,7 +1267,7 @@ read_collection(SerdReader* reader, ReadContext ctx, SerdNode** dest)
 		node        = ctx.subject;  // invariant
 	}
 
-	return end_collection(reader, ctx, n1, n2, st);
+	return end_collection(reader, ctx, st);
 }
 
 static SerdStatus
@@ -1310,7 +1290,6 @@ read_subject(SerdReader* reader, ReadContext ctx, SerdNode** dest, int* s_type)
 	}
 
 	if (ate_dot) {
-		pop_node(reader, *dest);
 		return r_err(reader, SERD_ERR_BAD_SYNTAX, "subject ends with `.'\n");
 	}
 
@@ -1376,7 +1355,6 @@ read_base(SerdReader* reader, bool sparql, bool token)
 	if (reader->sink->base) {
 		TRY(st, reader->sink->base(reader->sink->handle, uri));
 	}
-	pop_node(reader, uri);
 
 	read_ws_star(reader);
 	if (!sparql) {
@@ -1405,7 +1383,6 @@ read_prefixID(SerdReader* reader, bool sparql, bool token)
 	}
 
 	if (eat_byte_check(reader, ':') != ':') {
-		pop_node(reader, name);
 		return SERD_ERR_BAD_SYNTAX;
 	}
 
@@ -1416,8 +1393,6 @@ read_prefixID(SerdReader* reader, bool sparql, bool token)
 	if (reader->sink->prefix) {
 		st = reader->sink->prefix(reader->sink->handle, name, uri);
 	}
-	pop_node(reader, uri);
-	pop_node(reader, name);
 	if (!sparql) {
 		read_ws_star(reader);
 		st = eat_byte_check(reader, '.') ? SERD_SUCCESS : SERD_ERR_BAD_SYNTAX;
@@ -1455,8 +1430,10 @@ read_wrappedGraph(SerdReader* reader, ReadContext* ctx)
 
 	read_ws_star(reader);
 	while (peek_byte(reader) != '}') {
-		bool ate_dot = false;
-		int  s_type  = 0;
+		const size_t orig_stack_size = reader->stack.size;
+		bool         ate_dot         = false;
+		int          s_type          = 0;
+
 		ctx->subject = 0;
 		SerdStatus st = read_subject(reader, *ctx, &ctx->subject, &s_type);
 		if (st) {
@@ -1465,7 +1442,7 @@ read_wrappedGraph(SerdReader* reader, ReadContext* ctx)
 			return r_err(reader, SERD_ERR_BAD_SYNTAX,
 			             "missing predicate object list\n");
 		}
-		pop_node(reader, ctx->subject);
+		serd_stack_pop_to(&reader->stack, orig_stack_size);
 		read_ws_star(reader);
 		if (peek_byte(reader) == '.') {
 			eat_byte_safe(reader, '.');
@@ -1538,7 +1515,6 @@ read_n3_statement(SerdReader* reader)
 			TRY(st, read_labelOrSubject(reader, &ctx.graph));
 			read_ws_star(reader);
 			TRY(st, read_wrappedGraph(reader, &ctx));
-			pop_node(reader, ctx.graph);
 			ctx.graph = 0;
 			read_ws_star(reader);
 		} else if (read_ws_star(reader) && peek_byte(reader) == '{') {
@@ -1547,9 +1523,8 @@ read_n3_statement(SerdReader* reader)
 				             "invalid graph name\n");
 			}
 			ctx.graph   = ctx.subject;
-			ctx.subject = 0;
+			ctx.subject = NULL;
 			TRY(st, read_wrappedGraph(reader, &ctx));
-			pop_node(reader, ctx.graph);
 			read_ws_star(reader);
 		} else if ((st = read_triples(reader, ctx, &ate_dot))) {
 			if (st == SERD_FAILURE && s_type == '[') {
@@ -1582,13 +1557,16 @@ SerdStatus
 read_turtleTrigDoc(SerdReader* reader)
 {
 	while (!reader->source.eof) {
-		const SerdStatus st = read_n3_statement(reader);
+		const size_t     orig_stack_size = reader->stack.size;
+		const SerdStatus st              = read_n3_statement(reader);
 		if (st > SERD_FAILURE) {
 			if (reader->strict) {
+				serd_stack_pop_to(&reader->stack, orig_stack_size);
 				return st;
 			}
 			skip_until(reader, '\n');
 		}
+		serd_stack_pop_to(&reader->stack, orig_stack_size);
 	}
 	return SERD_SUCCESS;
 }
@@ -1598,6 +1576,8 @@ read_nquadsDoc(SerdReader* reader)
 {
 	SerdStatus st = SERD_SUCCESS;
 	while (!reader->source.eof) {
+		const size_t orig_stack_size = reader->stack.size;
+
 		SerdStatementFlags flags   = 0;
 		ReadContext        ctx     = { 0, 0, 0, 0, 0, 0, &flags };
 		bool               ate_dot = false;
@@ -1641,10 +1621,7 @@ read_nquadsDoc(SerdReader* reader)
 
 		TRY(st, emit_statement(reader, ctx, ctx.object));
 
-		pop_node(reader, ctx.graph);
-		pop_node(reader, ctx.lang);
-		pop_node(reader, ctx.datatype);
-		pop_node(reader, ctx.object);
+		serd_stack_pop_to(&reader->stack, orig_stack_size);
 	}
 	return SERD_SUCCESS;
 }