Use SerdBuffer for mutable buffers

This avoids const violations from abusing SerdChunk as a mutable buffer
for string sinks.

7 files changed, 56 insertions, 33 deletions

diff --git a/NEWS b/NEWS
index b54e8bd4..e1009660 100644
--- a/NEWS
+++ b/NEWS
@@ -1,3 +1,17 @@
+serd (1.0.0) unstable;
+
+  * Use SerdBuffer for mutable buffers instead of abusing SerdChunk
+  * Add serd_node_new_relative_uri()
+  * Fix construction and comparison of URIs with UTF-8 characters
+  * Report I/O errors with message and return appropriate status code
+  * Report missing statement separator errors
+  * Fix potential out of bounds read
+  * Fix unaligned memory access, undefined behaviour which breaks on ARM
+  * Fix documentation generation
+  * Update serdi man page
+
+ -- David Robillard <d@drobilla.net>  Mon, 10 Jul 2017 11:28:59 +0200
+
 serd (0.29.3) unstable;
 
   * Clarify errors returned by serd_env_expand()
diff --git a/serd/serd.h b/serd/serd.h
index b3056239..49ee3c3a 100644
--- a/serd/serd.h
+++ b/serd/serd.h
@@ -231,6 +231,14 @@ typedef struct {
 } SerdChunk;
 
 /**
+   A mutable buffer in memory.
+*/
+typedef struct {
+	void*  buf;  /**< Buffer */
+	size_t len;  /**< Size of buffer in bytes */
+} SerdBuffer;
+
+/**
    An error description.
 */
 typedef struct {
@@ -955,24 +963,24 @@ serd_file_sink(const void* buf, size_t len, void* stream);
 /**
    A convenience sink function for writing to a string.
 
-   This function can be used as a SerdSink to write to a SerdChunk which is
+   This function can be used as a SerdSink to write to a SerdBuffer which is
    resized as necessary with realloc().  The `stream` parameter must point to
-   an initialized SerdChunk.  When the write is finished, the string should be
-   retrieved with serd_chunk_sink_finish().
+   an initialized SerdBuffer.  When the write is finished, the string should be
+   retrieved with serd_buffer_sink_finish().
 */
 SERD_API
 size_t
-serd_chunk_sink(const void* buf, size_t len, void* stream);
+serd_buffer_sink(const void* buf, size_t len, void* stream);
 
 /**
-   Finish a serialisation to a chunk with serd_chunk_sink().
+   Finish a serialisation to a chunk with serd_buffer_sink().
 
    The returned string is the result of the serialisation, which is NULL
    terminated (by this function) and owned by the caller.
 */
 SERD_API
 uint8_t*
-serd_chunk_sink_finish(SerdChunk* stream);
+serd_buffer_sink_finish(SerdBuffer* stream);
 
 /**
    Set a function to be called when errors occur during writing.
diff --git a/src/node.c b/src/node.c
index 10df10d9..1472ad13 100644
--- a/src/node.c
+++ b/src/node.c
@@ -183,27 +183,28 @@ serd_node_new_file_uri(const uint8_t* path,
 		         evil ? "/" : "");
 	}
 
-	SerdChunk chunk = { uri, uri_len };
+	SerdBuffer buffer = { uri, uri_len };
 	for (size_t i = 0; i < path_len; ++i) {
 		if (evil && path[i] == '\\') {
-			serd_chunk_sink("/", 1, &chunk);
+			serd_buffer_sink("/", 1, &buffer);
 		} else if (path[i] == '%') {
-			serd_chunk_sink("%%", 2, &chunk);
+			serd_buffer_sink("%%", 2, &buffer);
 		} else if (!escape || is_uri_path_char(path[i])) {
-			serd_chunk_sink(path + i, 1, &chunk);
+			serd_buffer_sink(path + i, 1, &buffer);
 		} else {
 			char escape_str[4] = { '%', 0, 0, 0 };
 			snprintf(escape_str + 1, sizeof(escape_str) - 1, "%X", path[i]);
-			serd_chunk_sink(escape_str, 3, &chunk);
+			serd_buffer_sink(escape_str, 3, &buffer);
 		}
 	}
-	serd_chunk_sink_finish(&chunk);
+	serd_buffer_sink_finish(&buffer);
 
 	if (out) {
-		serd_uri_parse(chunk.buf, out);
+		serd_uri_parse((const uint8_t*)buffer.buf, out);
 	}
 
-	return serd_node_from_substring(SERD_URI, chunk.buf, chunk.len);
+	return serd_node_from_substring(
+		SERD_URI, (const uint8_t*)buffer.buf, buffer.len);
 }
 
 SERD_API
diff --git a/src/uri.c b/src/uri.c
index 7b172e42..b13a1e6f 100644
--- a/src/uri.c
+++ b/src/uri.c
@@ -72,27 +72,27 @@ serd_file_uri_parse(const uint8_t* uri, uint8_t** hostname)
 		++path;
 	}
 
-	SerdChunk chunk = { NULL, 0 };
+	SerdBuffer buffer = { NULL, 0 };
 	for (const uint8_t* s = path; *s; ++s) {
 		if (*s == '%') {
 			if (*(s + 1) == '%') {
-				serd_chunk_sink("%", 1, &chunk);
+				serd_buffer_sink("%", 1, &buffer);
 				++s;
 			} else if (is_hexdig(*(s + 1)) && is_hexdig(*(s + 2))) {
 				const uint8_t code[3] = { *(s + 1), *(s + 2), 0 };
 				uint32_t num;
 				sscanf((const char*)code, "%X", &num);
 				const uint8_t c = num;
-				serd_chunk_sink(&c, 1, &chunk);
+				serd_buffer_sink(&c, 1, &buffer);
 				s += 2;
 			} else {
 				s += 2;  // Junk escape, ignore
 			}
 		} else {
-			serd_chunk_sink(s, 1, &chunk);
+			serd_buffer_sink(s, 1, &buffer);
 		}
 	}
-	return serd_chunk_sink_finish(&chunk);
+	return serd_buffer_sink_finish(&buffer);
 }
 
 SERD_API
diff --git a/src/writer.c b/src/writer.c
index 603ca65e..26bf5e5a 100644
--- a/src/writer.c
+++ b/src/writer.c
@@ -976,19 +976,19 @@ serd_file_sink(const void* buf, size_t len, void* stream)
 
 SERD_API
 size_t
-serd_chunk_sink(const void* buf, size_t len, void* stream)
+serd_buffer_sink(const void* buf, size_t len, void* stream)
 {
-	SerdChunk* chunk = (SerdChunk*)stream;
-	chunk->buf = (uint8_t*)realloc((uint8_t*)chunk->buf, chunk->len + len);
-	memcpy((uint8_t*)chunk->buf + chunk->len, buf, len);
-	chunk->len += len;
+	SerdBuffer* buffer = (SerdBuffer*)stream;
+	buffer->buf = (char*)realloc(buffer->buf, buffer->len + len);
+	memcpy((uint8_t*)buffer->buf + buffer->len, buf, len);
+	buffer->len += len;
 	return len;
 }
 
 SERD_API
 uint8_t*
-serd_chunk_sink_finish(SerdChunk* stream)
+serd_buffer_sink_finish(SerdBuffer* stream)
 {
-	serd_chunk_sink("", 1, stream);
+	serd_buffer_sink("", 1, stream);
 	return (uint8_t*)stream->buf;
 }
diff --git a/tests/serd_test.c b/tests/serd_test.c
index b80c8b82..62621e16 100644
--- a/tests/serd_test.c
+++ b/tests/serd_test.c
@@ -573,10 +573,10 @@ main(void)
 
 	serd_writer_free(writer);
 
-	// Test chunk sink
-	SerdChunk chunk = { NULL, 0 };
+	// Test buffer sink
+	SerdBuffer buffer = { NULL, 0 };
 	writer = serd_writer_new(
-		SERD_TURTLE, (SerdStyle)0, env, NULL, serd_chunk_sink, &chunk);
+		SERD_TURTLE, (SerdStyle)0, env, NULL, serd_buffer_sink, &buffer);
 
 	o = serd_node_from_string(SERD_URI, USTR("http://example.org/base"));
 	if (serd_writer_set_base_uri(writer, &o)) {
@@ -584,10 +584,10 @@ main(void)
 	}
 
 	serd_writer_free(writer);
-	uint8_t* out = serd_chunk_sink_finish(&chunk);
+	uint8_t* out = serd_buffer_sink_finish(&buffer);
 
 	if (strcmp((const char*)out, "@base <http://example.org/base> .\n")) {
-		FAILF("Incorrect chunk output:\n%s\n", chunk.buf);
+		FAILF("Incorrect buffer output:\n%s\n", buffer.buf);
 	}
 
 	free(out);
diff --git a/wscript b/wscript
index fdadf860..f77d2437 100644
--- a/wscript
+++ b/wscript
@@ -10,8 +10,8 @@ import waflib.extras.autowaf as autowaf
 # major increment <=> incompatible changes
 # minor increment <=> compatible changes (additions)
 # micro increment <=> no interface changes
-SERD_VERSION       = '0.29.2'
-SERD_MAJOR_VERSION = '0'
+SERD_VERSION       = '1.0.0'
+SERD_MAJOR_VERSION = '1'
 
 # Mandatory waf variables
 APPNAME = 'serd'        # Package name for waf dist