Format all code with clang-format

31 files changed, 4918 insertions, 4625 deletions

diff --git a/.clang-format b/.clang-format
new file mode 100644
index 00000000..06635478
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,24 @@
+---
+AlignConsecutiveAssignments: true
+AlignConsecutiveDeclarations: true
+AlignEscapedNewlinesLeft: true
+BasedOnStyle: Mozilla
+BraceWrapping:
+  AfterNamespace: false
+  AfterClass: true
+  AfterEnum: false
+  AfterExternBlock: false
+  AfterFunction: true
+  AfterStruct: false
+  SplitEmptyFunction: false
+  SplitEmptyRecord: false
+BreakBeforeBraces: Custom
+Cpp11BracedListStyle: true
+IndentCaseLabels: false
+IndentPPDirectives: AfterHash
+KeepEmptyLinesAtTheStartOfBlocks: false
+SpacesInContainerLiterals: false
+StatementMacros:
+  - SERD_API
+  - SERD_DEPRECATED_BY
+...
diff --git a/include/serd/serd.h b/include/serd/serd.h
index 6dc33441..32a60f29 100644
--- a/include/serd/serd.h
+++ b/include/serd/serd.h
@@ -26,54 +26,59 @@
 #include <stdio.h>
 
 #if defined(SERD_SHARED) && defined(SERD_INTERNAL) && defined(_WIN32)
-#    define SERD_API __declspec(dllexport)
+#  define SERD_API __declspec(dllexport)
 #elif defined(SERD_SHARED) && defined(_WIN32)
-#    define SERD_API __declspec(dllimport)
+#  define SERD_API __declspec(dllimport)
 #elif defined(SERD_SHARED) && defined(__GNUC__)
-#    define SERD_API __attribute__((visibility("default")))
+#  define SERD_API __attribute__((visibility("default")))
 #else
-#    define SERD_API
+#  define SERD_API
 #endif
 
 #ifdef __GNUC__
-#    define SERD_PURE_FUNC __attribute__((pure))
-#    define SERD_CONST_FUNC __attribute__((const))
+#  define SERD_PURE_FUNC __attribute__((pure))
+#  define SERD_CONST_FUNC __attribute__((const))
 #else
-#    define SERD_PURE_FUNC
-#    define SERD_CONST_FUNC
+#  define SERD_PURE_FUNC
+#  define SERD_CONST_FUNC
 #endif
 
 #ifdef __clang__
-#    define SERD_NONNULL _Nonnull
-#    define SERD_NULLABLE _Nullable
-#    define SERD_ALLOCATED _Null_unspecified
+#  define SERD_NONNULL _Nonnull
+#  define SERD_NULLABLE _Nullable
+#  define SERD_ALLOCATED _Null_unspecified
 #else
-#    define SERD_NONNULL
-#    define SERD_NULLABLE
-#    define SERD_ALLOCATED
+#  define SERD_NONNULL
+#  define SERD_NULLABLE
+#  define SERD_ALLOCATED
 #endif
 
-#define SERD_PURE_API SERD_API SERD_PURE_FUNC
-#define SERD_CONST_API SERD_API SERD_CONST_FUNC
+#define SERD_PURE_API \
+  SERD_API            \
+  SERD_PURE_FUNC
+
+#define SERD_CONST_API \
+  SERD_API             \
+  SERD_CONST_FUNC
 
 #ifndef SERD_DISABLE_DEPRECATED
-#    if defined(__clang__)
-#        define SERD_DEPRECATED_BY(rep) __attribute__((deprecated("", rep)))
-#    elif defined(__GNUC__) && __GNUC__ > 4
-#        define SERD_DEPRECATED_BY(rep) __attribute__((deprecated("Use " rep)))
-#    elif defined(__GNUC__)
-#        define SERD_DEPRECATED_BY(rep) __attribute__((deprecated))
-#    else
-#        define SERD_DEPRECATED_BY(rep)
-#    endif
+#  if defined(__clang__)
+#    define SERD_DEPRECATED_BY(rep) __attribute__((deprecated("", rep)))
+#  elif defined(__GNUC__) && __GNUC__ > 4
+#    define SERD_DEPRECATED_BY(rep) __attribute__((deprecated("Use " rep)))
+#  elif defined(__GNUC__)
+#    define SERD_DEPRECATED_BY(rep) __attribute__((deprecated))
+#  else
+#    define SERD_DEPRECATED_BY(rep)
+#  endif
 #endif
 
 #ifdef __cplusplus
 extern "C" {
-#    if defined(__GNUC__)
-#        pragma GCC diagnostic push
-#        pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"
-#    endif
+#  if defined(__GNUC__)
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"
+#  endif
 #endif
 
 /**
@@ -93,35 +98,35 @@ typedef struct SerdWriterImpl SerdWriter;
 
 /// Return status code
 typedef enum {
-	SERD_SUCCESS,        ///< No error
-	SERD_FAILURE,        ///< Non-fatal failure
-	SERD_ERR_UNKNOWN,    ///< Unknown error
-	SERD_ERR_BAD_SYNTAX, ///< Invalid syntax
-	SERD_ERR_BAD_ARG,    ///< Invalid argument
-	SERD_ERR_NOT_FOUND,  ///< Not found
-	SERD_ERR_ID_CLASH,   ///< Encountered clashing blank node IDs
-	SERD_ERR_BAD_CURIE,  ///< Invalid CURIE (e.g. prefix does not exist)
-	SERD_ERR_INTERNAL    ///< Unexpected internal error (should not happen)
+  SERD_SUCCESS,        ///< No error
+  SERD_FAILURE,        ///< Non-fatal failure
+  SERD_ERR_UNKNOWN,    ///< Unknown error
+  SERD_ERR_BAD_SYNTAX, ///< Invalid syntax
+  SERD_ERR_BAD_ARG,    ///< Invalid argument
+  SERD_ERR_NOT_FOUND,  ///< Not found
+  SERD_ERR_ID_CLASH,   ///< Encountered clashing blank node IDs
+  SERD_ERR_BAD_CURIE,  ///< Invalid CURIE (e.g. prefix does not exist)
+  SERD_ERR_INTERNAL    ///< Unexpected internal error (should not happen)
 } SerdStatus;
 
 /// RDF syntax type
 typedef enum {
-	SERD_TURTLE   = 1, ///< Terse triples http://www.w3.org/TR/turtle
-	SERD_NTRIPLES = 2, ///< Line-based triples http://www.w3.org/TR/n-triples/
-	SERD_NQUADS   = 3, ///< Line-based quads http://www.w3.org/TR/n-quads/
-	SERD_TRIG     = 4  ///< Terse quads http://www.w3.org/TR/trig/
+  SERD_TURTLE   = 1, ///< Terse triples http://www.w3.org/TR/turtle
+  SERD_NTRIPLES = 2, ///< Line-based triples http://www.w3.org/TR/n-triples/
+  SERD_NQUADS   = 3, ///< Line-based quads http://www.w3.org/TR/n-quads/
+  SERD_TRIG     = 4  ///< Terse quads http://www.w3.org/TR/trig/
 } SerdSyntax;
 
 /// Flags indicating inline abbreviation information for a statement
 typedef enum {
-	SERD_EMPTY_S      = 1u << 1u, ///< Empty blank node subject
-	SERD_EMPTY_O      = 1u << 2u, ///< Empty blank node object
-	SERD_ANON_S_BEGIN = 1u << 3u, ///< Start of anonymous subject
-	SERD_ANON_O_BEGIN = 1u << 4u, ///< Start of anonymous object
-	SERD_ANON_CONT    = 1u << 5u, ///< Continuation of anonymous node
-	SERD_LIST_S_BEGIN = 1u << 6u, ///< Start of list subject
-	SERD_LIST_O_BEGIN = 1u << 7u, ///< Start of list object
-	SERD_LIST_CONT    = 1u << 8u  ///< Continuation of list
+  SERD_EMPTY_S      = 1u << 1u, ///< Empty blank node subject
+  SERD_EMPTY_O      = 1u << 2u, ///< Empty blank node object
+  SERD_ANON_S_BEGIN = 1u << 3u, ///< Start of anonymous subject
+  SERD_ANON_O_BEGIN = 1u << 4u, ///< Start of anonymous object
+  SERD_ANON_CONT    = 1u << 5u, ///< Continuation of anonymous node
+  SERD_LIST_S_BEGIN = 1u << 6u, ///< Start of list subject
+  SERD_LIST_O_BEGIN = 1u << 7u, ///< Start of list object
+  SERD_LIST_CONT    = 1u << 8u  ///< Continuation of list
 } SerdStatementFlag;
 
 /// Bitwise OR of SerdStatementFlag values
@@ -139,52 +144,52 @@ typedef uint32_t SerdStatementFlags;
    node types.
 */
 typedef enum {
-	/**
-	   The type of a nonexistent node.
-
-	   This type is useful as a sentinel, but is never emitted by the reader.
-	*/
-	SERD_NOTHING = 0,
-
-	/**
-	   Literal value.
-
-	   A literal optionally has either a language, or a datatype (not both).
-	*/
-	SERD_LITERAL = 1,
-
-	/**
-	   URI (absolute or relative).
-
-	   Value is an unquoted URI string, which is either a relative reference
-	   with respect to the current base URI (e.g. "foo/bar"), or an absolute
-	   URI (e.g. "http://example.org/foo").
-	   @see [RFC3986](http://tools.ietf.org/html/rfc3986)
-	*/
-	SERD_URI = 2,
-
-	/**
-	   CURIE, a shortened URI.
-
-	   Value is an unquoted CURIE string relative to the current environment,
-	   e.g. "rdf:type".  @see [CURIE Syntax 1.0](http://www.w3.org/TR/curie)
-	*/
-	SERD_CURIE = 3,
-
-	/**
-	   A blank node.
-
-	   Value is a blank node ID without any syntactic prefix, like "id3", which
-	   is meaningful only within this serialisation.  @see [RDF 1.1
-	   Turtle](http://www.w3.org/TR/turtle/#grammar-production-BLANK_NODE_LABEL)
-	*/
-	SERD_BLANK = 4
+  /**
+     The type of a nonexistent node.
+
+     This type is useful as a sentinel, but is never emitted by the reader.
+  */
+  SERD_NOTHING = 0,
+
+  /**
+     Literal value.
+
+     A literal optionally has either a language, or a datatype (not both).
+  */
+  SERD_LITERAL = 1,
+
+  /**
+     URI (absolute or relative).
+
+     Value is an unquoted URI string, which is either a relative reference
+     with respect to the current base URI (e.g. "foo/bar"), or an absolute
+     URI (e.g. "http://example.org/foo").
+     @see [RFC3986](http://tools.ietf.org/html/rfc3986)
+  */
+  SERD_URI = 2,
+
+  /**
+     CURIE, a shortened URI.
+
+     Value is an unquoted CURIE string relative to the current environment,
+     e.g. "rdf:type".  @see [CURIE Syntax 1.0](http://www.w3.org/TR/curie)
+  */
+  SERD_CURIE = 3,
+
+  /**
+     A blank node.
+
+     Value is a blank node ID without any syntactic prefix, like "id3", which
+     is meaningful only within this serialisation.  @see [RDF 1.1
+     Turtle](http://www.w3.org/TR/turtle/#grammar-production-BLANK_NODE_LABEL)
+  */
+  SERD_BLANK = 4
 } SerdType;
 
 /// Flags indicating certain string properties relevant to serialisation
 typedef enum {
-	SERD_HAS_NEWLINE = 1u << 0u, ///< Contains line breaks ('\\n' or '\\r')
-	SERD_HAS_QUOTE   = 1u << 1u  ///< Contains quotes ('"')
+  SERD_HAS_NEWLINE = 1u << 0u, ///< Contains line breaks ('\\n' or '\\r')
+  SERD_HAS_QUOTE   = 1u << 1u  ///< Contains quotes ('"')
 } SerdNodeFlag;
 
 /// Bitwise OR of SerdNodeFlag values
@@ -192,27 +197,27 @@ typedef uint32_t SerdNodeFlags;
 
 /// A syntactic RDF node
 typedef struct {
-	const uint8_t* SERD_NULLABLE buf;     ///< Value string
-	size_t                       n_bytes; ///< Size in bytes (excluding null)
-	size_t                       n_chars; ///< String length (excluding null)
-	SerdNodeFlags                flags;   ///< Node flags (string properties)
-	SerdType                     type;    ///< Node type
+  const uint8_t* SERD_NULLABLE buf;     ///< Value string
+  size_t                       n_bytes; ///< Size in bytes (excluding null)
+  size_t                       n_chars; ///< String length (excluding null)
+  SerdNodeFlags                flags;   ///< Node flags (string properties)
+  SerdType                     type;    ///< Node type
 } SerdNode;
 
 /// An unterminated string fragment
 typedef struct {
-	const uint8_t* SERD_NULLABLE buf; ///< Start of chunk
-	size_t                       len; ///< Length of chunk in bytes
+  const uint8_t* SERD_NULLABLE buf; ///< Start of chunk
+  size_t                       len; ///< Length of chunk in bytes
 } SerdChunk;
 
 /// An error description
 typedef struct {
-	SerdStatus                   status;   ///< Error code
-	const uint8_t* SERD_NULLABLE filename; ///< File with error
-	unsigned                     line;     ///< Line in file with error or 0
-	unsigned                     col;      ///< Column in file with error
-	const char* SERD_NONNULL     fmt;      ///< Printf-style format string
-	va_list* SERD_NONNULL        args;     ///< Arguments for fmt
+  SerdStatus                   status;   ///< Error code
+  const uint8_t* SERD_NULLABLE filename; ///< File with error
+  unsigned                     line;     ///< Line in file with error or 0
+  unsigned                     col;      ///< Column in file with error
+  const char* SERD_NONNULL     fmt;      ///< Printf-style format string
+  va_list* SERD_NONNULL        args;     ///< Arguments for fmt
 } SerdError;
 
 /**
@@ -223,12 +228,12 @@ typedef struct {
    in-place without allocating memory.
 */
 typedef struct {
-	SerdChunk scheme;    ///< Scheme
-	SerdChunk authority; ///< Authority
-	SerdChunk path_base; ///< Path prefix if relative
-	SerdChunk path;      ///< Path suffix
-	SerdChunk query;     ///< Query
-	SerdChunk fragment;  ///< Fragment
+  SerdChunk scheme;    ///< Scheme
+  SerdChunk authority; ///< Authority
+  SerdChunk path_base; ///< Path prefix if relative
+  SerdChunk path;      ///< Path suffix
+  SerdChunk query;     ///< Query
+  SerdChunk fragment;  ///< Fragment
 } SerdURI;
 
 /**
@@ -239,11 +244,11 @@ typedef struct {
    does not support abbreviation and is always ASCII.
 */
 typedef enum {
-	SERD_STYLE_ABBREVIATED = 1u << 0u, ///< Abbreviate triples when possible.
-	SERD_STYLE_ASCII       = 1u << 1u, ///< Escape all non-ASCII characters.
-	SERD_STYLE_RESOLVED    = 1u << 2u, ///< Resolve URIs against base URI.
-	SERD_STYLE_CURIED      = 1u << 3u, ///< Shorten URIs into CURIEs.
-	SERD_STYLE_BULK        = 1u << 4u, ///< Write output in pages.
+  SERD_STYLE_ABBREVIATED = 1u << 0u, ///< Abbreviate triples when possible.
+  SERD_STYLE_ASCII       = 1u << 1u, ///< Escape all non-ASCII characters.
+  SERD_STYLE_RESOLVED    = 1u << 2u, ///< Resolve URIs against base URI.
+  SERD_STYLE_CURIED      = 1u << 3u, ///< Shorten URIs into CURIEs.
+  SERD_STYLE_BULK        = 1u << 4u, ///< Write output in pages.
 } SerdStyle;
 
 /**
@@ -353,9 +358,8 @@ typedef size_t (*SerdSink)(const void* SERD_NONNULL buf,
    @{
 */
 
-static const SerdURI SERD_URI_NULL = {
-	{NULL, 0}, {NULL, 0}, {NULL, 0}, {NULL, 0}, {NULL, 0}, {NULL, 0}
-};
+static const SerdURI SERD_URI_NULL =
+  {{NULL, 0}, {NULL, 0}, {NULL, 0}, {NULL, 0}, {NULL, 0}, {NULL, 0}};
 
 /**
    Return the local path for `uri`, or NULL if `uri` is not a file URI.
@@ -364,7 +368,8 @@ static const SerdURI SERD_URI_NULL = {
    encoding and other issues are not handled, to properly convert a file URI to
    a path, use serd_file_uri_parse().
 */
-SERD_API SERD_DEPRECATED_BY("serd_file_uri_parse")
+SERD_API
+SERD_DEPRECATED_BY("serd_file_uri_parse")
 const uint8_t* SERD_NULLABLE
 serd_uri_to_path(const uint8_t* SERD_NONNULL uri);
 
@@ -431,7 +436,7 @@ serd_uri_serialise_relative(const SerdURI* SERD_NONNULL  uri,
    @{
 */
 
-static const SerdNode SERD_NODE_NULL = { NULL, 0, 0, 0, SERD_NOTHING };
+static const SerdNode SERD_NODE_NULL = {NULL, 0, 0, 0, SERD_NOTHING};
 
 /**
    Make a (shallow) node from `str`.
@@ -450,16 +455,16 @@ serd_node_from_string(SerdType type, const uint8_t* SERD_NULLABLE str);
 */
 SERD_API
 SerdNode
-serd_node_from_substring(SerdType                    type,
+serd_node_from_substring(SerdType                     type,
                          const uint8_t* SERD_NULLABLE str,
-                         size_t                      len);
+                         size_t                       len);
 
 /// Simple wrapper for serd_node_new_uri() to resolve a URI node
 SERD_API
 SerdNode
 serd_node_new_uri_from_node(const SerdNode* SERD_NONNULL uri_node,
-                            const SerdURI* SERD_NULLABLE  base,
-                            SerdURI* SERD_NULLABLE        out);
+                            const SerdURI* SERD_NULLABLE base,
+                            SerdURI* SERD_NULLABLE       out);
 
 /// Simple wrapper for serd_node_new_uri() to resolve a URI string
 SERD_API
@@ -621,14 +626,14 @@ typedef SerdStatus (*SerdPrefixSink)(void* SERD_NULLABLE          handle,
    Called for every RDF statement in the serialisation.
 */
 typedef SerdStatus (*SerdStatementSink)(
-    void* SERD_NULLABLE           handle,
-    SerdStatementFlags            flags,
-    const SerdNode* SERD_NULLABLE graph,
-    const SerdNode* SERD_NONNULL  subject,
-    const SerdNode* SERD_NONNULL  predicate,
-    const SerdNode* SERD_NONNULL  object,
-    const SerdNode* SERD_NULLABLE object_datatype,
-    const SerdNode* SERD_NULLABLE object_lang);
+  void* SERD_NULLABLE           handle,
+  SerdStatementFlags            flags,
+  const SerdNode* SERD_NULLABLE graph,
+  const SerdNode* SERD_NONNULL  subject,
+  const SerdNode* SERD_NONNULL  predicate,
+  const SerdNode* SERD_NONNULL  object,
+  const SerdNode* SERD_NULLABLE object_datatype,
+  const SerdNode* SERD_NULLABLE object_lang);
 
 /**
    Sink (callback) for anonymous node end markers
@@ -1041,10 +1046,10 @@ serd_writer_finish(SerdWriter* SERD_NONNULL writer);
 */
 
 #ifdef __cplusplus
-#    if defined(__GNUC__)
-#        pragma GCC diagnostic pop
-#    endif
-}  /* extern "C" */
+#  if defined(__GNUC__)
+#    pragma GCC diagnostic pop
+#  endif
+} /* extern "C" */
 #endif
 
-#endif  /* SERD_SERD_H */
+#endif /* SERD_SERD_H */
diff --git a/src/attributes.h b/src/attributes.h
index 3ca797a4..fa60b862 100644
--- a/src/attributes.h
+++ b/src/attributes.h
@@ -18,9 +18,9 @@
 #define SERD_ATTRIBUTES_H
 
 #ifdef __GNUC__
-#    define SERD_MALLOC_FUNC __attribute__((malloc))
+#  define SERD_MALLOC_FUNC __attribute__((malloc))
 #else
-#    define SERD_MALLOC_FUNC
+#  define SERD_MALLOC_FUNC
 #endif
 
 #endif // SERD_ATTRIBUTES_H
diff --git a/src/base64.c b/src/base64.c
index 763c2d2e..6f292d02 100644
--- a/src/base64.c
+++ b/src/base64.c
@@ -32,7 +32,7 @@
    @see <a href="http://tools.ietf.org/html/rfc3548#section-3">RFC3548 S3</a>.
 */
 static const uint8_t b64_map[] =
-	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
 /**
    Base64 decoding table.
@@ -42,27 +42,28 @@ static const uint8_t b64_map[] =
    A '$' is a placeholder for characters not in the base64 alphabet.
 */
 static const char b64_unmap[] =
-	"$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$m$$$ncdefghijkl$$$$$$"
-	"$/0123456789:;<=>?@ABCDEFGH$$$$$$IJKLMNOPQRSTUVWXYZ[\\]^_`ab$$$$"
-	"$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$"
-	"$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$";
+  "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$m$$$ncdefghijkl$$$$$$"
+  "$/0123456789:;<=>?@ABCDEFGH$$$$$$IJKLMNOPQRSTUVWXYZ[\\]^_`ab$$$$"
+  "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$"
+  "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$";
 
 /** Encode 3 raw bytes to 4 base64 characters. */
 static inline void
 encode_chunk(uint8_t out[4], const uint8_t in[3], size_t n_in)
 {
-	out[0] = b64_map[in[0] >> 2];
-	out[1] = b64_map[((in[0] & 0x03) << 4) | ((in[1] & 0xF0) >> 4)];
-	out[2] = ((n_in > 1)
-	          ? (b64_map[((in[1] & 0x0F) << 2) | ((in[2] & 0xC0) >> 6)])
-	          : (uint8_t)'=');
-	out[3] = ((n_in > 2) ? b64_map[in[2] & 0x3F] : (uint8_t)'=');
+  out[0] = b64_map[in[0] >> 2];
+  out[1] = b64_map[((in[0] & 0x03) << 4) | ((in[1] & 0xF0) >> 4)];
+
+  out[2] = (n_in > 1) ? (b64_map[((in[1] & 0x0F) << 2) | ((in[2] & 0xC0) >> 6)])
+                      : (uint8_t)'=';
+
+  out[3] = ((n_in > 2) ? b64_map[in[2] & 0x3F] : (uint8_t)'=');
 }
 
 size_t
 serd_base64_get_length(const size_t size, const bool wrap_lines)
 {
-	return (size + 2) / 3 * 4 + (wrap_lines * ((size - 1) / 57));
+  return (size + 2) / 3 * 4 + (wrap_lines * ((size - 1) / 57));
 }
 
 bool
@@ -71,54 +72,61 @@ serd_base64_encode(uint8_t* const    str,
                    const size_t      size,
                    const bool        wrap_lines)
 {
-	bool           has_newline = false;
-	for (size_t i = 0, j = 0; i < size; i += 3, j += 4) {
-		uint8_t in[4] = { 0, 0, 0, 0 };
-		size_t  n_in  = MIN(3, size - i);
-		memcpy(in, (const uint8_t*)buf + i, n_in);
+  bool has_newline = false;
+
+  for (size_t i = 0, j = 0; i < size; i += 3, j += 4) {
+    uint8_t in[4] = {0, 0, 0, 0};
+    size_t  n_in  = MIN(3, size - i);
+    memcpy(in, (const uint8_t*)buf + i, n_in);
 
-		if (wrap_lines && i > 0 && (i % 57) == 0) {
-			str[j++]    = '\n';
-			has_newline = true;
-		}
+    if (wrap_lines && i > 0 && (i % 57) == 0) {
+      str[j++]    = '\n';
+      has_newline = true;
+    }
 
-		encode_chunk(str + j, in, n_in);
-	}
+    encode_chunk(str + j, in, n_in);
+  }
 
-	return has_newline;
+  return has_newline;
 }
 
 static inline uint8_t
 unmap(const uint8_t in)
 {
-	return (uint8_t)(b64_unmap[in] - 47);
+  return (uint8_t)(b64_unmap[in] - 47);
 }
 
 /** Decode 4 base64 characters to 3 raw bytes. */
 static inline size_t
 decode_chunk(const uint8_t in[4], uint8_t out[3])
 {
-	out[0] = (uint8_t)(((unmap(in[0]) << 2))        | unmap(in[1]) >> 4);
-	out[1] = (uint8_t)(((unmap(in[1]) << 4) & 0xF0) | unmap(in[2]) >> 2);
-	out[2] = (uint8_t)(((unmap(in[2]) << 6) & 0xC0) | unmap(in[3]));
-	return 1 + (in[2] != '=') + ((in[2] != '=') && (in[3] != '='));
+  out[0] = (uint8_t)(((unmap(in[0]) << 2)) | unmap(in[1]) >> 4);
+  out[1] = (uint8_t)(((unmap(in[1]) << 4) & 0xF0) | unmap(in[2]) >> 2);
+  out[2] = (uint8_t)(((unmap(in[2]) << 6) & 0xC0) | unmap(in[3]));
+  return 1 + (in[2] != '=') + ((in[2] != '=') && (in[3] != '='));
 }
 
 void*
 serd_base64_decode(const uint8_t* str, size_t len, size_t* size)
 {
-	void* buf = malloc((len * 3) / 4 + 2);
-	*size     = 0;
-	for (size_t i = 0, j = 0; i < len; j += 3) {
-		uint8_t in[] = "====";
-		size_t  n_in = 0;
-		for (; i < len && n_in < 4; ++n_in) {
-			for (; i < len && !is_base64(str[i]); ++i) {} // Skip junk
-			in[n_in] = str[i++];
-		}
-		if (n_in > 1) {
-			*size += decode_chunk(in, (uint8_t*)buf + j);
-		}
-	}
-	return buf;
+  void* buf = malloc((len * 3) / 4 + 2);
+
+  *size = 0;
+  for (size_t i = 0, j = 0; i < len; j += 3) {
+    uint8_t in[] = "====";
+    size_t  n_in = 0;
+    for (; i < len && n_in < 4; ++n_in) {
+      for (; i < len && !is_base64(str[i]); ++i) {
+        // Skip junk
+      }
+
+      in[n_in] = str[i++];
+    }
+
+    if (n_in > 1) {
+      *size += decode_chunk(in, (uint8_t*)buf + j);
+    }
+  }
+
+  return buf;
 }
diff --git a/src/base64.h b/src/base64.h
index 7fd29fef..0969b2d3 100644
--- a/src/base64.h
+++ b/src/base64.h
@@ -45,4 +45,4 @@ serd_base64_get_length(size_t size, bool wrap_lines);
 bool
 serd_base64_encode(uint8_t* str, const void* buf, size_t size, bool wrap_lines);
 
-#endif  // SERD_BASE64_H
+#endif // SERD_BASE64_H
diff --git a/src/byte_sink.h b/src/byte_sink.h
index 71d525ce..b58d5d39 100644
--- a/src/byte_sink.h
+++ b/src/byte_sink.h
@@ -27,73 +27,72 @@
 #include <string.h>
 
 typedef struct SerdByteSinkImpl {
-	SerdSink sink;
-	void*    stream;
-	uint8_t* buf;
-	size_t   size;
-	size_t   block_size;
+  SerdSink sink;
+  void*    stream;
+  uint8_t* buf;
+  size_t   size;
+  size_t   block_size;
 } SerdByteSink;
 
 static inline SerdByteSink
 serd_byte_sink_new(SerdSink sink, void* stream, size_t block_size)
 {
-	SerdByteSink bsink;
-	bsink.sink       = sink;
-	bsink.stream     = stream;
-	bsink.size       = 0;
-	bsink.block_size = block_size;
-	bsink.buf        = ((block_size > 1)
-	                    ? (uint8_t*)serd_allocate_buffer(block_size)
-	                    : NULL);
-	return bsink;
+  SerdByteSink bsink = {sink, stream, NULL, 0, block_size};
+
+  if (block_size > 1) {
+    bsink.buf = (uint8_t*)serd_allocate_buffer(block_size);
+  }
+
+  return bsink;
 }
 
 static inline void
 serd_byte_sink_flush(SerdByteSink* bsink)
 {
-	if (bsink->block_size > 1 && bsink->size > 0) {
-		bsink->sink(bsink->buf, bsink->size, bsink->stream);
-		bsink->size = 0;
-	}
+  if (bsink->block_size > 1 && bsink->size > 0) {
+    bsink->sink(bsink->buf, bsink->size, bsink->stream);
+    bsink->size = 0;
+  }
 }
 
 static inline void
 serd_byte_sink_free(SerdByteSink* bsink)
 {
-	serd_byte_sink_flush(bsink);
-	serd_free_aligned(bsink->buf);
-	bsink->buf = NULL;
+  serd_byte_sink_flush(bsink);
+  serd_free_aligned(bsink->buf);
+  bsink->buf = NULL;
 }
 
 static inline size_t
 serd_byte_sink_write(const void* buf, size_t len, SerdByteSink* bsink)
 {
-	if (len == 0) {
-		return 0;
-	}
-
-	if (bsink->block_size == 1) {
-		return bsink->sink(buf, len, bsink->stream);
-	}
-
-	const size_t orig_len = len;
-	while (len) {
-		const size_t space = bsink->block_size - bsink->size;
-		const size_t n     = MIN(space, len);
-
-		// Write as much as possible into the remaining buffer space
-		memcpy(bsink->buf + bsink->size, buf, n);
-		bsink->size += n;
-		buf          = (const uint8_t*)buf + n;
-		len         -= n;
-
-		// Flush page if buffer is full
-		if (bsink->size == bsink->block_size) {
-			bsink->sink(bsink->buf, bsink->block_size, bsink->stream);
-			bsink->size = 0;
-		}
-	}
-	return orig_len;
+  if (len == 0) {
+    return 0;
+  }
+
+  if (bsink->block_size == 1) {
+    return bsink->sink(buf, len, bsink->stream);
+  }
+
+  const size_t orig_len = len;
+  while (len) {
+    const size_t space = bsink->block_size - bsink->size;
+    const size_t n     = MIN(space, len);
+
+    // Write as much as possible into the remaining buffer space
+    memcpy(bsink->buf + bsink->size, buf, n);
+    bsink->size += n;
+    buf = (const uint8_t*)buf + n;
+    len -= n;
+
+    // Flush page if buffer is full
+    if (bsink->size == bsink->block_size) {
+      bsink->sink(bsink->buf, bsink->block_size, bsink->stream);
+      bsink->size = 0;
+    }
+  }
+
+  return orig_len;
 }
 
-#endif  // SERD_BYTE_SINK_H
+#endif // SERD_BYTE_SINK_H
diff --git a/src/byte_source.c b/src/byte_source.c
index a62f7a47..1b461fd0 100644
--- a/src/byte_source.c
+++ b/src/byte_source.c
@@ -27,23 +27,23 @@
 SerdStatus
 serd_byte_source_page(SerdByteSource* source)
 {
-	source->read_head = 0;
-	const size_t n_read = source->read_func(
-		source->file_buf, 1, source->page_size, source->stream);
-
-	if (n_read == 0) {
-		source->file_buf[0] = '\0';
-		source->eof         = true;
-		return (source->error_func(source->stream)
-		        ? SERD_ERR_UNKNOWN : SERD_FAILURE);
-	}
-
-	if (n_read < source->page_size) {
-		source->file_buf[n_read] = '\0';
-		source->buf_size         = n_read;
-	}
-
-	return SERD_SUCCESS;
+  source->read_head = 0;
+  const size_t n_read =
+    source->read_func(source->file_buf, 1, source->page_size, source->stream);
+
+  if (n_read == 0) {
+    source->file_buf[0] = '\0';
+    source->eof         = true;
+    return (source->error_func(source->stream) ? SERD_ERR_UNKNOWN
+                                               : SERD_FAILURE);
+  }
+
+  if (n_read < source->page_size) {
+    source->file_buf[n_read] = '\0';
+    source->buf_size         = n_read;
+  }
+
+  return SERD_SUCCESS;
 }
 
 SerdStatus
@@ -54,58 +54,59 @@ serd_byte_source_open_source(SerdByteSource*     source,
                              const uint8_t*      name,
                              size_t              page_size)
 {
-	const Cursor cur = { name, 1, 1 };
-
-	memset(source, '\0', sizeof(*source));
-	source->stream      = stream;
-	source->from_stream = true;
-	source->page_size   = page_size;
-	source->buf_size    = page_size;
-	source->cur         = cur;
-	source->error_func  = error_func;
-	source->read_func   = read_func;
-
-	if (page_size > 1) {
-		source->file_buf = (uint8_t*)serd_allocate_buffer(page_size);
-		source->read_buf = source->file_buf;
-		memset(source->file_buf, '\0', page_size);
-	} else {
-		source->read_buf = &source->read_byte;
-	}
-
-	return SERD_SUCCESS;
+  const Cursor cur = {name, 1, 1};
+
+  memset(source, '\0', sizeof(*source));
+  source->stream      = stream;
+  source->from_stream = true;
+  source->page_size   = page_size;
+  source->buf_size    = page_size;
+  source->cur         = cur;
+  source->error_func  = error_func;
+  source->read_func   = read_func;
+
+  if (page_size > 1) {
+    source->file_buf = (uint8_t*)serd_allocate_buffer(page_size);
+    source->read_buf = source->file_buf;
+    memset(source->file_buf, '\0', page_size);
+  } else {
+    source->read_buf = &source->read_byte;
+  }
+
+  return SERD_SUCCESS;
 }
 
 SerdStatus
 serd_byte_source_prepare(SerdByteSource* source)
 {
-	source->prepared = true;
+  source->prepared = true;
 
-	if (source->from_stream) {
-		return (source->page_size > 1 ? serd_byte_source_page(source)
-		                              : serd_byte_source_advance(source));
-	}
+  if (source->from_stream) {
+    return (source->page_size > 1 ? serd_byte_source_page(source)
+                                  : serd_byte_source_advance(source));
+  }
 
-	return SERD_SUCCESS;
+  return SERD_SUCCESS;
 }
 
 SerdStatus
 serd_byte_source_open_string(SerdByteSource* source, const uint8_t* utf8)
 {
-	const Cursor cur = { (const uint8_t*)"(string)", 1, 1 };
+  const Cursor cur = {(const uint8_t*)"(string)", 1, 1};
 
-	memset(source, '\0', sizeof(*source));
-	source->cur      = cur;
-	source->read_buf = utf8;
-	return SERD_SUCCESS;
+  memset(source, '\0', sizeof(*source));
+  source->cur      = cur;
+  source->read_buf = utf8;
+  return SERD_SUCCESS;
 }
 
 SerdStatus
 serd_byte_source_close(SerdByteSource* source)
 {
-	if (source->page_size > 1) {
-		serd_free_aligned(source->file_buf);
-	}
-	memset(source, '\0', sizeof(*source));
-	return SERD_SUCCESS;
+  if (source->page_size > 1) {
+    serd_free_aligned(source->file_buf);
+  }
+
+  memset(source, '\0', sizeof(*source));
+  return SERD_SUCCESS;
 }
diff --git a/src/byte_source.h b/src/byte_source.h
index a0dfa140..90958f41 100644
--- a/src/byte_source.h
+++ b/src/byte_source.h
@@ -26,31 +26,29 @@
 #include <stdio.h>
 
 typedef struct {
-	const uint8_t* filename;
-	unsigned       line;
-	unsigned       col;
+  const uint8_t* filename;
+  unsigned       line;
+  unsigned       col;
 } Cursor;
 
 typedef struct {
-	SerdSource          read_func;    ///< Read function (e.g. fread)
-	SerdStreamErrorFunc error_func;   ///< Error function (e.g. ferror)
-	void*               stream;       ///< Stream (e.g. FILE)
-	size_t              page_size;    ///< Number of bytes to read at a time
-	size_t              buf_size;     ///< Number of bytes in file_buf
-	Cursor              cur;          ///< Cursor for error reporting
-	uint8_t*            file_buf;     ///< Buffer iff reading pages from a file
-	const uint8_t*      read_buf;     ///< Pointer to file_buf or read_byte
-	size_t              read_head;    ///< Offset into read_buf
-	uint8_t             read_byte;    ///< 1-byte 'buffer' used when not paging
-	bool                from_stream;  ///< True iff reading from `stream`
-	bool                prepared;     ///< True iff prepared for reading
-	bool                eof;          ///< True iff end of file reached
+  SerdSource          read_func;   ///< Read function (e.g. fread)
+  SerdStreamErrorFunc error_func;  ///< Error function (e.g. ferror)
+  void*               stream;      ///< Stream (e.g. FILE)
+  size_t              page_size;   ///< Number of bytes to read at a time
+  size_t              buf_size;    ///< Number of bytes in file_buf
+  Cursor              cur;         ///< Cursor for error reporting
+  uint8_t*            file_buf;    ///< Buffer iff reading pages from a file
+  const uint8_t*      read_buf;    ///< Pointer to file_buf or read_byte
+  size_t              read_head;   ///< Offset into read_buf
+  uint8_t             read_byte;   ///< 1-byte 'buffer' used when not paging
+  bool                from_stream; ///< True iff reading from `stream`
+  bool                prepared;    ///< True iff prepared for reading
+  bool                eof;         ///< True iff end of file reached
 } SerdByteSource;
 
 SerdStatus
-serd_byte_source_open_file(SerdByteSource* source,
-                           FILE*           file,
-                           bool            bulk);
+serd_byte_source_open_file(SerdByteSource* source, FILE* file, bool bulk);
 
 SerdStatus
 serd_byte_source_open_string(SerdByteSource* source, const uint8_t* utf8);
@@ -75,44 +73,48 @@ serd_byte_source_page(SerdByteSource* source);
 static inline uint8_t
 serd_byte_source_peek(SerdByteSource* source)
 {
-	assert(source->prepared);
-	return source->read_buf[source->read_head];
+  assert(source->prepared);
+  return source->read_buf[source->read_head];
 }
 
 static inline SerdStatus
 serd_byte_source_advance(SerdByteSource* source)
 {
-	SerdStatus st = SERD_SUCCESS;
-
-	switch (serd_byte_source_peek(source)) {
-	case '\n': ++source->cur.line; source->cur.col = 0; break;
-	default:   ++source->cur.col;
-	}
-
-	const bool was_eof = source->eof;
-	if (source->from_stream) {
-		source->eof = false;
-		if (source->page_size > 1) {
-			if (++source->read_head == source->page_size) {
-				st = serd_byte_source_page(source);
-			} else if (source->read_head == source->buf_size) {
-				source->eof = true;
-			}
-		} else {
-			if (!source->read_func(&source->read_byte, 1, 1, source->stream)) {
-				source->eof = true;
-				st = source->error_func(source->stream) ? SERD_ERR_UNKNOWN
-				                                        : SERD_FAILURE;
-			}
-		}
-	} else if (!source->eof) {
-		++source->read_head; // Move to next character in string
-		if (source->read_buf[source->read_head] == '\0') {
-			source->eof = true;
-		}
-	}
-
-	return (was_eof && source->eof) ? SERD_FAILURE : st;
+  SerdStatus st = SERD_SUCCESS;
+
+  switch (serd_byte_source_peek(source)) {
+  case '\n':
+    ++source->cur.line;
+    source->cur.col = 0;
+    break;
+  default:
+    ++source->cur.col;
+  }
+
+  const bool was_eof = source->eof;
+  if (source->from_stream) {
+    source->eof = false;
+    if (source->page_size > 1) {
+      if (++source->read_head == source->page_size) {
+        st = serd_byte_source_page(source);
+      } else if (source->read_head == source->buf_size) {
+        source->eof = true;
+      }
+    } else {
+      if (!source->read_func(&source->read_byte, 1, 1, source->stream)) {
+        source->eof = true;
+        st =
+          source->error_func(source->stream) ? SERD_ERR_UNKNOWN : SERD_FAILURE;
+      }
+    }
+  } else if (!source->eof) {
+    ++source->read_head; // Move to next character in string
+    if (source->read_buf[source->read_head] == '\0') {
+      source->eof = true;
+    }
+  }
+
+  return (was_eof && source->eof) ? SERD_FAILURE : st;
 }
 
-#endif  // SERD_BYTE_SOURCE_H
+#endif // SERD_BYTE_SOURCE_H
diff --git a/src/env.c b/src/env.c
index d11553b4..d2f7a3f5 100644
--- a/src/env.c
+++ b/src/env.c
@@ -23,141 +23,137 @@
 #include <string.h>
 
 typedef struct {
-	SerdNode name;
-	SerdNode uri;
+  SerdNode name;
+  SerdNode uri;
 } SerdPrefix;
 
 struct SerdEnvImpl {
-	SerdPrefix* prefixes;
-	size_t      n_prefixes;
-	SerdNode    base_uri_node;
-	SerdURI     base_uri;
+  SerdPrefix* prefixes;
+  size_t      n_prefixes;
+  SerdNode    base_uri_node;
+  SerdURI     base_uri;
 };
 
 SerdEnv*
 serd_env_new(const SerdNode* base_uri)
 {
-	SerdEnv* env = (SerdEnv*)calloc(1, sizeof(struct SerdEnvImpl));
-	if (env && base_uri) {
-		serd_env_set_base_uri(env, base_uri);
-	}
-	return env;
+  SerdEnv* env = (SerdEnv*)calloc(1, sizeof(struct SerdEnvImpl));
+  if (env && base_uri) {
+    serd_env_set_base_uri(env, base_uri);
+  }
+
+  return env;
 }
 
 void
 serd_env_free(SerdEnv* env)
 {
-	if (!env) {
-		return;
-	}
-
-	for (size_t i = 0; i < env->n_prefixes; ++i) {
-		serd_node_free(&env->prefixes[i].name);
-		serd_node_free(&env->prefixes[i].uri);
-	}
-	free(env->prefixes);
-	serd_node_free(&env->base_uri_node);
-	free(env);
+  if (!env) {
+    return;
+  }
+
+  for (size_t i = 0; i < env->n_prefixes; ++i) {
+    serd_node_free(&env->prefixes[i].name);
+    serd_node_free(&env->prefixes[i].uri);
+  }
+
+  free(env->prefixes);
+  serd_node_free(&env->base_uri_node);
+  free(env);
 }
 
 const SerdNode*
-serd_env_get_base_uri(const SerdEnv* env,
-                      SerdURI*       out)
+serd_env_get_base_uri(const SerdEnv* env, SerdURI* out)
 {
-	if (out) {
-		*out = env->base_uri;
-	}
-	return &env->base_uri_node;
+  if (out) {
+    *out = env->base_uri;
+  }
+
+  return &env->base_uri_node;
 }
 
 SerdStatus
-serd_env_set_base_uri(SerdEnv*        env,
-                      const SerdNode* uri)
+serd_env_set_base_uri(SerdEnv* env, const SerdNode* uri)
 {
-	if (!env || (uri && uri->type != SERD_URI)) {
-		return SERD_ERR_BAD_ARG;
-	}
-
-	if (!uri || !uri->buf) {
-		serd_node_free(&env->base_uri_node);
-		env->base_uri_node = SERD_NODE_NULL;
-		env->base_uri      = SERD_URI_NULL;
-		return SERD_SUCCESS;
-	}
-
-	// Resolve base URI and create a new node and URI for it
-	SerdURI  base_uri;
-	SerdNode base_uri_node = serd_node_new_uri_from_node(
-		uri, &env->base_uri, &base_uri);
-
-	// Replace the current base URI
-	serd_node_free(&env->base_uri_node);
-	env->base_uri_node = base_uri_node;
-	env->base_uri      = base_uri;
-
-	return SERD_SUCCESS;
+  if (!env || (uri && uri->type != SERD_URI)) {
+    return SERD_ERR_BAD_ARG;
+  }
+
+  if (!uri || !uri->buf) {
+    serd_node_free(&env->base_uri_node);
+    env->base_uri_node = SERD_NODE_NULL;
+    env->base_uri      = SERD_URI_NULL;
+    return SERD_SUCCESS;
+  }
+
+  // Resolve base URI and create a new node and URI for it
+  SerdURI  base_uri;
+  SerdNode base_uri_node =
+    serd_node_new_uri_from_node(uri, &env->base_uri, &base_uri);
+
+  // Replace the current base URI
+  serd_node_free(&env->base_uri_node);
+  env->base_uri_node = base_uri_node;
+  env->base_uri      = base_uri;
+
+  return SERD_SUCCESS;
 }
 
 static inline SERD_PURE_FUNC SerdPrefix*
-serd_env_find(const SerdEnv* env,
-              const uint8_t* name,
-              size_t         name_len)
+serd_env_find(const SerdEnv* env, const uint8_t* name, size_t name_len)
 {
-	for (size_t i = 0; i < env->n_prefixes; ++i) {
-		const SerdNode* const prefix_name = &env->prefixes[i].name;
-		if (prefix_name->n_bytes == name_len) {
-			if (!memcmp(prefix_name->buf, name, name_len)) {
-				return &env->prefixes[i];
-			}
-		}
-	}
-	return NULL;
+  for (size_t i = 0; i < env->n_prefixes; ++i) {
+    const SerdNode* const prefix_name = &env->prefixes[i].name;
+    if (prefix_name->n_bytes == name_len) {
+      if (!memcmp(prefix_name->buf, name, name_len)) {
+        return &env->prefixes[i];
+      }
+    }
+  }
+
+  return NULL;
 }
 
 static void
-serd_env_add(SerdEnv*        env,
-             const SerdNode* name,
-             const SerdNode* uri)
+serd_env_add(SerdEnv* env, const SerdNode* name, const SerdNode* uri)
 {
-	SerdPrefix* const prefix = serd_env_find(env, name->buf, name->n_bytes);
-	if (prefix) {
-		if (!serd_node_equals(&prefix->uri, uri)) {
-			SerdNode old_prefix_uri = prefix->uri;
-			prefix->uri = serd_node_copy(uri);
-			serd_node_free(&old_prefix_uri);
-		}
-	} else {
-		env->prefixes = (SerdPrefix*)realloc(
-			env->prefixes, (++env->n_prefixes) * sizeof(SerdPrefix));
-		env->prefixes[env->n_prefixes - 1].name = serd_node_copy(name);
-		env->prefixes[env->n_prefixes - 1].uri  = serd_node_copy(uri);
-	}
+  SerdPrefix* const prefix = serd_env_find(env, name->buf, name->n_bytes);
+  if (prefix) {
+    if (!serd_node_equals(&prefix->uri, uri)) {
+      SerdNode old_prefix_uri = prefix->uri;
+      prefix->uri             = serd_node_copy(uri);
+      serd_node_free(&old_prefix_uri);
+    }
+  } else {
+    env->prefixes = (SerdPrefix*)realloc(
+      env->prefixes, (++env->n_prefixes) * sizeof(SerdPrefix));
+    env->prefixes[env->n_prefixes - 1].name = serd_node_copy(name);
+    env->prefixes[env->n_prefixes - 1].uri  = serd_node_copy(uri);
+  }
 }
 
 SerdStatus
-serd_env_set_prefix(SerdEnv*        env,
-                    const SerdNode* name,
-                    const SerdNode* uri)
+serd_env_set_prefix(SerdEnv* env, const SerdNode* name, const SerdNode* uri)
 {
-	if (!name->buf || uri->type != SERD_URI) {
-		return SERD_ERR_BAD_ARG;
-	}
-
-	if (serd_uri_string_has_scheme(uri->buf)) {
-		// Set prefix to absolute URI
-		serd_env_add(env, name, uri);
-	} else {
-		// Resolve relative URI and create a new node and URI for it
-		SerdURI  abs_uri;
-		SerdNode abs_uri_node = serd_node_new_uri_from_node(
-			uri, &env->base_uri, &abs_uri);
-
-		// Set prefix to resolved (absolute) URI
-		serd_env_add(env, name, &abs_uri_node);
-		serd_node_free(&abs_uri_node);
-	}
-
-	return SERD_SUCCESS;
+  if (!name->buf || uri->type != SERD_URI) {
+    return SERD_ERR_BAD_ARG;
+  }
+
+  if (serd_uri_string_has_scheme(uri->buf)) {
+    // Set prefix to absolute URI
+    serd_env_add(env, name, uri);
+  } else {
+    // Resolve relative URI and create a new node and URI for it
+    SerdURI  abs_uri;
+    SerdNode abs_uri_node =
+      serd_node_new_uri_from_node(uri, &env->base_uri, &abs_uri);
+
+    // Set prefix to resolved (absolute) URI
+    serd_env_add(env, name, &abs_uri_node);
+    serd_node_free(&abs_uri_node);
+  }
+
+  return SERD_SUCCESS;
 }
 
 SerdStatus
@@ -165,10 +161,10 @@ serd_env_set_prefix_from_strings(SerdEnv*       env,
                                  const uint8_t* name,
                                  const uint8_t* uri)
 {
-	const SerdNode name_node = serd_node_from_string(SERD_LITERAL, name);
-	const SerdNode uri_node  = serd_node_from_string(SERD_URI, uri);
+  const SerdNode name_node = serd_node_from_string(SERD_LITERAL, name);
+  const SerdNode uri_node  = serd_node_from_string(SERD_URI, uri);
 
-	return serd_env_set_prefix(env, &name_node, &uri_node);
+  return serd_env_set_prefix(env, &name_node, &uri_node);
 }
 
 bool
@@ -177,20 +173,20 @@ serd_env_qualify(const SerdEnv*  env,
                  SerdNode*       prefix,
                  SerdChunk*      suffix)
 {
-	for (size_t i = 0; i < env->n_prefixes; ++i) {
-		const SerdNode* const prefix_uri = &env->prefixes[i].uri;
-		if (uri->n_bytes >= prefix_uri->n_bytes) {
-			if (!strncmp((const char*)uri->buf,
-			             (const char*)prefix_uri->buf,
-			             prefix_uri->n_bytes)) {
-				*prefix = env->prefixes[i].name;
-				suffix->buf = uri->buf + prefix_uri->n_bytes;
-				suffix->len = uri->n_bytes - prefix_uri->n_bytes;
-				return true;
-			}
-		}
-	}
-	return false;
+  for (size_t i = 0; i < env->n_prefixes; ++i) {
+    const SerdNode* const prefix_uri = &env->prefixes[i].uri;
+    if (uri->n_bytes >= prefix_uri->n_bytes) {
+      if (!strncmp((const char*)uri->buf,
+                   (const char*)prefix_uri->buf,
+                   prefix_uri->n_bytes)) {
+        *prefix     = env->prefixes[i].name;
+        suffix->buf = uri->buf + prefix_uri->n_bytes;
+        suffix->len = uri->n_bytes - prefix_uri->n_bytes;
+        return true;
+      }
+    }
+  }
+  return false;
 }
 
 SerdStatus
@@ -199,61 +195,62 @@ serd_env_expand(const SerdEnv*  env,
                 SerdChunk*      uri_prefix,
                 SerdChunk*      uri_suffix)
 {
-	const uint8_t* const colon = (const uint8_t*)memchr(
-		curie->buf, ':', curie->n_bytes + 1);
-	if (curie->type != SERD_CURIE || !colon) {
-		return SERD_ERR_BAD_ARG;
-	}
-
-	const size_t            name_len = (size_t)(colon - curie->buf);
-	const SerdPrefix* const prefix   = serd_env_find(env, curie->buf, name_len);
-	if (prefix) {
-		uri_prefix->buf = prefix->uri.buf;
-		uri_prefix->len = prefix->uri.n_bytes;
-		uri_suffix->buf = colon + 1;
-		uri_suffix->len = curie->n_bytes - name_len - 1;
-		return SERD_SUCCESS;
-	}
-	return SERD_ERR_BAD_CURIE;
+  const uint8_t* const colon =
+    (const uint8_t*)memchr(curie->buf, ':', curie->n_bytes + 1);
+  if (curie->type != SERD_CURIE || !colon) {
+    return SERD_ERR_BAD_ARG;
+  }
+
+  const size_t            name_len = (size_t)(colon - curie->buf);
+  const SerdPrefix* const prefix   = serd_env_find(env, curie->buf, name_len);
+  if (prefix) {
+    uri_prefix->buf = prefix->uri.buf;
+    uri_prefix->len = prefix->uri.n_bytes;
+    uri_suffix->buf = colon + 1;
+    uri_suffix->len = curie->n_bytes - name_len - 1;
+    return SERD_SUCCESS;
+  }
+  return SERD_ERR_BAD_CURIE;
 }
 
 SerdNode
-serd_env_expand_node(const SerdEnv*  env,
-                     const SerdNode* node)
+serd_env_expand_node(const SerdEnv* env, const SerdNode* node)
 {
-	switch (node->type) {
-	case SERD_NOTHING:
-	case SERD_LITERAL:
-		break;
-	case SERD_URI: {
-		SerdURI ignored;
-		return serd_node_new_uri_from_node(node, &env->base_uri, &ignored);
-	}
-	case SERD_CURIE: {
-		SerdChunk prefix;
-		SerdChunk suffix;
-		if (serd_env_expand(env, node, &prefix, &suffix)) {
-			return SERD_NODE_NULL;
-		}
-		const size_t len = prefix.len + suffix.len;
-		uint8_t*     buf = (uint8_t*)malloc(len + 1);
-		SerdNode     ret = { buf, len, 0, 0, SERD_URI };
-		snprintf((char*)buf, len + 1, "%s%s", prefix.buf, suffix.buf);
-		ret.n_chars = serd_strlen(buf, NULL, NULL);
-		return ret;
-	}
-	case SERD_BLANK:
-		break;
-	}
-	return SERD_NODE_NULL;
+  switch (node->type) {
+  case SERD_NOTHING:
+  case SERD_LITERAL:
+    break;
+
+  case SERD_URI: {
+    SerdURI ignored;
+    return serd_node_new_uri_from_node(node, &env->base_uri, &ignored);
+  }
+
+  case SERD_CURIE: {
+    SerdChunk prefix;
+    SerdChunk suffix;
+    if (serd_env_expand(env, node, &prefix, &suffix)) {
+      return SERD_NODE_NULL;
+    }
+    const size_t len = prefix.len + suffix.len;
+    uint8_t*     buf = (uint8_t*)malloc(len + 1);
+    SerdNode     ret = {buf, len, 0, 0, SERD_URI};
+    snprintf((char*)buf, len + 1, "%s%s", prefix.buf, suffix.buf);
+    ret.n_chars = serd_strlen(buf, NULL, NULL);
+    return ret;
+  }
+
+  case SERD_BLANK:
+    break;
+  }
+
+  return SERD_NODE_NULL;
 }
 
 void
-serd_env_foreach(const SerdEnv* env,
-                 SerdPrefixSink func,
-                 void*          handle)
+serd_env_foreach(const SerdEnv* env, SerdPrefixSink func, void* handle)
 {
-	for (size_t i = 0; i < env->n_prefixes; ++i) {
-		func(handle, &env->prefixes[i].name, &env->prefixes[i].uri);
-	}
+  for (size_t i = 0; i < env->n_prefixes; ++i) {
+    func(handle, &env->prefixes[i].name, &env->prefixes[i].uri);
+  }
 }
diff --git a/src/n3.c b/src/n3.c
index c12b1ff0..e5fa4f94 100644
--- a/src/n3.c
+++ b/src/n3.c
@@ -30,12 +30,17 @@
 #include <stdlib.h>
 #include <string.h>
 
-#define TRY(st, exp) do { if (((st) = (exp))) { return (st); } } while (0)
+#define TRY(st, exp)      \
+  do {                    \
+    if (((st) = (exp))) { \
+      return (st);        \
+    }                     \
+  } while (0)
 
 static inline bool
 fancy_syntax(const SerdReader* reader)
 {
-	return reader->syntax == SERD_TURTLE || reader->syntax == SERD_TRIG;
+  return reader->syntax == SERD_TURTLE || reader->syntax == SERD_TRIG;
 }
 
 static SerdStatus
@@ -47,192 +52,197 @@ read_predicateObjectList(SerdReader* reader, ReadContext ctx, bool* ate_dot);
 static inline uint8_t
 read_HEX(SerdReader* reader)
 {
-	const int c = peek_byte(reader);
-	if (is_xdigit(c)) {
-		return (uint8_t)eat_byte_safe(reader, c);
-	}
+  const int c = peek_byte(reader);
+  if (is_xdigit(c)) {
+    return (uint8_t)eat_byte_safe(reader, c);
+  }
 
-	r_err(reader, SERD_ERR_BAD_SYNTAX, "invalid hexadecimal digit `%c'\n", c);
-	return 0;
+  r_err(reader, SERD_ERR_BAD_SYNTAX, "invalid hexadecimal digit `%c'\n", c);
+  return 0;
 }
 
 // Read UCHAR escape, initial \ is already eaten by caller
 static inline SerdStatus
 read_UCHAR(SerdReader* reader, Ref dest, uint32_t* char_code)
 {
-	const int b      = peek_byte(reader);
-	unsigned  length = 0;
-	switch (b) {
-	case 'U':
-		length = 8;
-		break;
-	case 'u':
-		length = 4;
-		break;
-	default:
-		return SERD_ERR_BAD_SYNTAX;
-	}
-	eat_byte_safe(reader, b);
-
-	uint8_t buf[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-	for (unsigned i = 0; i < length; ++i) {
-		if (!(buf[i] = read_HEX(reader))) {
-			return SERD_ERR_BAD_SYNTAX;
-		}
-	}
-
-	char*          endptr = NULL;
-	const uint32_t code   = (uint32_t)strtoul((const char*)buf, &endptr, 16);
-	assert(endptr == (char*)buf + length);
-
-	unsigned size = 0;
-	if (code < 0x00000080) {
-		size = 1;
-	} else if (code < 0x00000800) {
-		size = 2;
-	} else if (code < 0x00010000) {
-		size = 3;
-	} else if (code < 0x00110000) {
-		size = 4;
-	} else {
-		r_err(reader, SERD_ERR_BAD_SYNTAX,
-		      "unicode character 0x%X out of range\n", code);
-		push_bytes(reader, dest, replacement_char, 3);
-		*char_code = 0xFFFD;
-		return SERD_SUCCESS;
-	}
-
-	// Build output in buf
-	// (Note # of bytes = # of leading 1 bits in first byte)
-	uint32_t c = code;
-	switch (size) {
-	case 4:
-		buf[3] = (uint8_t)(0x80u | (c & 0x3Fu));
-		c >>= 6;
-		c |= (16 << 12);  // set bit 4
-        // fallthru
-	case 3:
-		buf[2] = (uint8_t)(0x80u | (c & 0x3Fu));
-		c >>= 6;
-		c |= (32 << 6);  // set bit 5
-        // fallthru
-	case 2:
-		buf[1] = (uint8_t)(0x80u | (c & 0x3Fu));
-		c >>= 6;
-		c |= 0xC0;  // set bits 6 and 7
-        // fallthru
-	case 1:
-		buf[0] = (uint8_t)c;
-		// fallthru
-	default:
-		break;
-	}
-
-	push_bytes(reader, dest, buf, size);
-	*char_code = code;
-	return SERD_SUCCESS;
+  const int b      = peek_byte(reader);
+  unsigned  length = 0;
+  switch (b) {
+  case 'U':
+    length = 8;
+    break;
+  case 'u':
+    length = 4;
+    break;
+  default:
+    return SERD_ERR_BAD_SYNTAX;
+  }
+
+  eat_byte_safe(reader, b);
+
+  uint8_t buf[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
+  for (unsigned i = 0; i < length; ++i) {
+    if (!(buf[i] = read_HEX(reader))) {
+      return SERD_ERR_BAD_SYNTAX;
+    }
+  }
+
+  char*          endptr = NULL;
+  const uint32_t code   = (uint32_t)strtoul((const char*)buf, &endptr, 16);
+  assert(endptr == (char*)buf + length);
+
+  unsigned size = 0;
+  if (code < 0x00000080) {
+    size = 1;
+  } else if (code < 0x00000800) {
+    size = 2;
+  } else if (code < 0x00010000) {
+    size = 3;
+  } else if (code < 0x00110000) {
+    size = 4;
+  } else {
+    r_err(reader,
+          SERD_ERR_BAD_SYNTAX,
+          "unicode character 0x%X out of range\n",
+          code);
+    push_bytes(reader, dest, replacement_char, 3);
+    *char_code = 0xFFFD;
+    return SERD_SUCCESS;
+  }
+
+  // Build output in buf
+  // (Note # of bytes = # of leading 1 bits in first byte)
+  uint32_t c = code;
+  switch (size) {
+  case 4:
+    buf[3] = (uint8_t)(0x80u | (c & 0x3Fu));
+    c >>= 6;
+    c |= (16 << 12); // set bit 4
+    /* fallthru */
+  case 3:
+    buf[2] = (uint8_t)(0x80u | (c & 0x3Fu));
+    c >>= 6;
+    c |= (32 << 6); // set bit 5
+    /* fallthru */
+  case 2:
+    buf[1] = (uint8_t)(0x80u | (c & 0x3Fu));
+    c >>= 6;
+    c |= 0xC0; // set bits 6 and 7
+    /* fallthru */
+  case 1:
+    buf[0] = (uint8_t)c;
+    /* fallthru */
+  default:
+    break;
+  }
+
+  push_bytes(reader, dest, buf, size);
+  *char_code = code;
+  return SERD_SUCCESS;
 }
 
 // Read ECHAR escape, initial \ is already eaten by caller
 static inline SerdStatus
 read_ECHAR(SerdReader* reader, Ref dest, SerdNodeFlags* flags)
 {
-	const int c = peek_byte(reader);
-	switch (c) {
-	case 't':
-		eat_byte_safe(reader, 't');
-		push_byte(reader, dest, '\t');
-		return SERD_SUCCESS;
-	case 'b':
-		eat_byte_safe(reader, 'b');
-		push_byte(reader, dest, '\b');
-		return SERD_SUCCESS;
-	case 'n':
-		*flags |= SERD_HAS_NEWLINE;
-		eat_byte_safe(reader, 'n');
-		push_byte(reader, dest, '\n');
-		return SERD_SUCCESS;
-	case 'r':
-		*flags |= SERD_HAS_NEWLINE;
-		eat_byte_safe(reader, 'r');
-		push_byte(reader, dest, '\r');
-		return SERD_SUCCESS;
-	case 'f':
-		eat_byte_safe(reader, 'f');
-		push_byte(reader, dest, '\f');
-		return SERD_SUCCESS;
-	case '\\': case '"': case '\'':
-		push_byte(reader, dest, eat_byte_safe(reader, c));
-		return SERD_SUCCESS;
-	default:
-		return SERD_ERR_BAD_SYNTAX;
-	}
+  const int c = peek_byte(reader);
+  switch (c) {
+  case 't':
+    eat_byte_safe(reader, 't');
+    push_byte(reader, dest, '\t');
+    return SERD_SUCCESS;
+  case 'b':
+    eat_byte_safe(reader, 'b');
+    push_byte(reader, dest, '\b');
+    return SERD_SUCCESS;
+  case 'n':
+    *flags |= SERD_HAS_NEWLINE;
+    eat_byte_safe(reader, 'n');
+    push_byte(reader, dest, '\n');
+    return SERD_SUCCESS;
+  case 'r':
+    *flags |= SERD_HAS_NEWLINE;
+    eat_byte_safe(reader, 'r');
+    push_byte(reader, dest, '\r');
+    return SERD_SUCCESS;
+  case 'f':
+    eat_byte_safe(reader, 'f');
+    push_byte(reader, dest, '\f');
+    return SERD_SUCCESS;
+  case '\\':
+  case '"':
+  case '\'':
+    push_byte(reader, dest, eat_byte_safe(reader, c));
+    return SERD_SUCCESS;
+  default:
+    return SERD_ERR_BAD_SYNTAX;
+  }
 }
 
 static inline SerdStatus
 bad_char(SerdReader* reader, const char* fmt, uint8_t c)
 {
-	// Skip bytes until the next start byte
-	for (int b = peek_byte(reader); b != EOF && ((uint8_t)b & 0x80);) {
-		eat_byte_safe(reader, b);
-		b = peek_byte(reader);
-	}
-
-	r_err(reader, SERD_ERR_BAD_SYNTAX, fmt, c);
-	return reader->strict ? SERD_ERR_BAD_SYNTAX : SERD_FAILURE;
+  // Skip bytes until the next start byte
+  for (int b = peek_byte(reader); b != EOF && ((uint8_t)b & 0x80);) {
+    eat_byte_safe(reader, b);
+    b = peek_byte(reader);
+  }
+
+  r_err(reader, SERD_ERR_BAD_SYNTAX, fmt, c);
+  return reader->strict ? SERD_ERR_BAD_SYNTAX : SERD_FAILURE;
 }
 
 static SerdStatus
 read_utf8_bytes(SerdReader* reader, uint8_t bytes[4], uint32_t* size, uint8_t c)
 {
-	*size = utf8_num_bytes(c);
-	if (*size <= 1 || *size > 4) {
-		return bad_char(reader, "invalid UTF-8 start 0x%X\n", c);
-	}
-
-	bytes[0] = c;
-	for (unsigned i = 1; i < *size; ++i) {
-		const int b = peek_byte(reader);
-		if (b == EOF || ((uint8_t)b & 0x80) == 0) {
-			return bad_char(reader, "invalid UTF-8 continuation 0x%X\n",
-			                (uint8_t)b);
-		}
-
-		eat_byte_safe(reader, b);
-		bytes[i] = (uint8_t)b;
-	}
-
-	return SERD_SUCCESS;
+  *size = utf8_num_bytes(c);
+  if (*size <= 1 || *size > 4) {
+    return bad_char(reader, "invalid UTF-8 start 0x%X\n", c);
+  }
+
+  bytes[0] = c;
+  for (unsigned i = 1; i < *size; ++i) {
+    const int b = peek_byte(reader);
+    if (b == EOF || ((uint8_t)b & 0x80) == 0) {
+      return bad_char(reader, "invalid UTF-8 continuation 0x%X\n", (uint8_t)b);
+    }
+
+    eat_byte_safe(reader, b);
+    bytes[i] = (uint8_t)b;
+  }
+
+  return SERD_SUCCESS;
 }
 
 static SerdStatus
 read_utf8_character(SerdReader* reader, Ref dest, uint8_t c)
 {
-	uint32_t   size     = 0;
-	uint8_t    bytes[4] = {0, 0, 0, 0};
-	SerdStatus st       = read_utf8_bytes(reader, bytes, &size, c);
-	if (st) {
-		push_bytes(reader, dest, replacement_char, 3);
-	} else {
-		push_bytes(reader, dest, bytes, size);
-	}
-	return st;
+  uint32_t   size     = 0;
+  uint8_t    bytes[4] = {0, 0, 0, 0};
+  SerdStatus st       = read_utf8_bytes(reader, bytes, &size, c);
+  if (st) {
+    push_bytes(reader, dest, replacement_char, 3);
+  } else {
+    push_bytes(reader, dest, bytes, size);
+  }
+
+  return st;
 }
 
 static SerdStatus
 read_utf8_code(SerdReader* reader, Ref dest, uint32_t* code, uint8_t c)
 {
-	uint32_t   size     = 0;
-	uint8_t    bytes[4] = {0, 0, 0, 0};
-	SerdStatus st       = read_utf8_bytes(reader, bytes, &size, c);
-	if (st) {
-		push_bytes(reader, dest, replacement_char, 3);
-		return st;
-	}
-
-	push_bytes(reader, dest, bytes, size);
-	*code = parse_counted_utf8_char(bytes, size);
-	return st;
+  uint32_t   size     = 0;
+  uint8_t    bytes[4] = {0, 0, 0, 0};
+  SerdStatus st       = read_utf8_bytes(reader, bytes, &size, c);
+  if (st) {
+    push_bytes(reader, dest, replacement_char, 3);
+    return st;
+  }
+
+  push_bytes(reader, dest, bytes, size);
+  *code = parse_counted_utf8_char(bytes, size);
+  return st;
 }
 
 // Read one character (possibly multi-byte)
@@ -240,72 +250,81 @@ read_utf8_code(SerdReader* reader, Ref dest, uint32_t* code, uint8_t c)
 static inline SerdStatus
 read_character(SerdReader* reader, Ref dest, SerdNodeFlags* flags, uint8_t c)
 {
-	if (!(c & 0x80)) {
-		switch (c) {
-		case 0xA: case 0xD:
-			*flags |= SERD_HAS_NEWLINE;
-			break;
-		case '"': case '\'':
-			*flags |= SERD_HAS_QUOTE;
-			break;
-		default:
-			break;
-		}
-		return push_byte(reader, dest, c);
-	}
-	return read_utf8_character(reader, dest, c);
+  if (!(c & 0x80)) {
+    switch (c) {
+    case 0xA:
+    case 0xD:
+      *flags |= SERD_HAS_NEWLINE;
+      break;
+    case '"':
+    case '\'':
+      *flags |= SERD_HAS_QUOTE;
+      break;
+    default:
+      break;
+    }
+    return push_byte(reader, dest, c);
+  }
+
+  return read_utf8_character(reader, dest, c);
 }
 
 // [10] comment ::= '#' ( [^#xA #xD] )*
 static void
 read_comment(SerdReader* reader)
 {
-	eat_byte_safe(reader, '#');
-	int c = 0;
-	while (((c = peek_byte(reader)) != 0xA) && c != 0xD && c != EOF && c) {
-		eat_byte_safe(reader, c);
-	}
+  eat_byte_safe(reader, '#');
+  int c = 0;
+  while (((c = peek_byte(reader)) != 0xA) && c != 0xD && c != EOF && c) {
+    eat_byte_safe(reader, c);
+  }
 }
 
 // [24] ws ::= #x9 | #xA | #xD | #x20 | comment
 static inline bool
 read_ws(SerdReader* reader)
 {
-	const int c = peek_byte(reader);
-	switch (c) {
-	case 0x9: case 0xA: case 0xD: case 0x20:
-		eat_byte_safe(reader, c);
-		return true;
-	case '#':
-		read_comment(reader);
-		return true;
-	default:
-		return false;
-	}
+  const int c = peek_byte(reader);
+  switch (c) {
+  case 0x9:
+  case 0xA:
+  case 0xD:
+  case 0x20:
+    eat_byte_safe(reader, c);
+    return true;
+  case '#':
+    read_comment(reader);
+    return true;
+  default:
+    return false;
+  }
 }
 
 static inline bool
 read_ws_star(SerdReader* reader)
 {
-	while (read_ws(reader)) {}
-	return true;
+  while (read_ws(reader)) {
+  }
+
+  return true;
 }
 
 static inline bool
 peek_delim(SerdReader* reader, const char delim)
 {
-	read_ws_star(reader);
-	return peek_byte(reader) == delim;
+  read_ws_star(reader);
+  return peek_byte(reader) == delim;
 }
 
 static inline bool
 eat_delim(SerdReader* reader, const char delim)
 {
-	if (peek_delim(reader, delim)) {
-		eat_byte_safe(reader, delim);
-		return read_ws_star(reader);
-	}
-	return false;
+  if (peek_delim(reader, delim)) {
+    eat_byte_safe(reader, delim);
+    return read_ws_star(reader);
+  }
+
+  return false;
 }
 
 // STRING_LITERAL_LONG_QUOTE and STRING_LITERAL_LONG_SINGLE_QUOTE
@@ -316,39 +335,37 @@ read_STRING_LITERAL_LONG(SerdReader*    reader,
                          SerdNodeFlags* flags,
                          uint8_t        q)
 {
-	SerdStatus st = SERD_SUCCESS;
-
-	while (!(st && reader->strict)) {
-		const int c = peek_byte(reader);
-		if (c == '\\') {
-			eat_byte_safe(reader, c);
-			uint32_t code = 0;
-			if ((st = read_ECHAR(reader, ref, flags)) &&
-			    (st = read_UCHAR(reader, ref, &code))) {
-				return r_err(reader, st,
-				             "invalid escape `\\%c'\n", peek_byte(reader));
-			}
-		} else if (c == q) {
-			eat_byte_safe(reader, q);
-			const int q2 = eat_byte_safe(reader, peek_byte(reader));
-			const int q3 = peek_byte(reader);
-			if (q2 == q && q3 == q) {  // End of string
-				eat_byte_safe(reader, q3);
-				break;
-			}
-			*flags |= SERD_HAS_QUOTE;
-			push_byte(reader, ref, c);
-			st = read_character(reader, ref, flags, (uint8_t)q2);
-		} else if (c == EOF) {
-			return r_err(reader, SERD_ERR_BAD_SYNTAX,
-			             "end of file in long string\n");
-		} else {
-			st = read_character(
-				reader, ref, flags, (uint8_t)eat_byte_safe(reader, c));
-		}
-	}
-
-	return (st && reader->strict) ? st : SERD_SUCCESS;
+  SerdStatus st = SERD_SUCCESS;
+
+  while (!(st && reader->strict)) {
+    const int c = peek_byte(reader);
+    if (c == '\\') {
+      eat_byte_safe(reader, c);
+      uint32_t code = 0;
+      if ((st = read_ECHAR(reader, ref, flags)) &&
+          (st = read_UCHAR(reader, ref, &code))) {
+        return r_err(reader, st, "invalid escape `\\%c'\n", peek_byte(reader));
+      }
+    } else if (c == q) {
+      eat_byte_safe(reader, q);
+      const int q2 = eat_byte_safe(reader, peek_byte(reader));
+      const int q3 = peek_byte(reader);
+      if (q2 == q && q3 == q) { // End of string
+        eat_byte_safe(reader, q3);
+        break;
+      }
+      *flags |= SERD_HAS_QUOTE;
+      push_byte(reader, ref, c);
+      st = read_character(reader, ref, flags, (uint8_t)q2);
+    } else if (c == EOF) {
+      return r_err(reader, SERD_ERR_BAD_SYNTAX, "end of file in long string\n");
+    } else {
+      st =
+        read_character(reader, ref, flags, (uint8_t)eat_byte_safe(reader, c));
+    }
+  }
+
+  return (st && reader->strict) ? st : SERD_SUCCESS;
 }
 
 // STRING_LITERAL_QUOTE and STRING_LITERAL_SINGLE_QUOTE
@@ -359,689 +376,722 @@ read_STRING_LITERAL(SerdReader*    reader,
                     SerdNodeFlags* flags,
                     uint8_t        q)
 {
-	SerdStatus st = SERD_SUCCESS;
-
-	while (!(st && reader->strict)) {
-		const int c    = peek_byte(reader);
-		uint32_t  code = 0;
-		switch (c) {
-		case EOF:
-			return r_err(reader, SERD_ERR_BAD_SYNTAX,
-			             "end of file in short string\n");
-		case '\n': case '\r':
-			return r_err(reader, SERD_ERR_BAD_SYNTAX,
-			             "line end in short string\n");
-		case '\\':
-			eat_byte_safe(reader, c);
-			if ((st = read_ECHAR(reader, ref, flags)) &&
-			    (st = read_UCHAR(reader, ref, &code))) {
-				return r_err(reader, st,
-				             "invalid escape `\\%c'\n", peek_byte(reader));
-			}
-			break;
-		default:
-			if (c == q) {
-				eat_byte_check(reader, q);
-				return SERD_SUCCESS;
-			} else {
-				st = read_character(
-					reader, ref, flags, (uint8_t)eat_byte_safe(reader, c));
-			}
-		}
-	}
-
-	return st ? st
-	          : eat_byte_check(reader, q) ? SERD_SUCCESS : SERD_ERR_BAD_SYNTAX;
+  SerdStatus st = SERD_SUCCESS;
+
+  while (!(st && reader->strict)) {
+    const int c    = peek_byte(reader);
+    uint32_t  code = 0;
+    switch (c) {
+    case EOF:
+      return r_err(
+        reader, SERD_ERR_BAD_SYNTAX, "end of file in short string\n");
+    case '\n':
+    case '\r':
+      return r_err(reader, SERD_ERR_BAD_SYNTAX, "line end in short string\n");
+    case '\\':
+      eat_byte_safe(reader, c);
+      if ((st = read_ECHAR(reader, ref, flags)) &&
+          (st = read_UCHAR(reader, ref, &code))) {
+        return r_err(reader, st, "invalid escape `\\%c'\n", peek_byte(reader));
+      }
+      break;
+    default:
+      if (c == q) {
+        eat_byte_check(reader, q);
+        return SERD_SUCCESS;
+      } else {
+        st =
+          read_character(reader, ref, flags, (uint8_t)eat_byte_safe(reader, c));
+      }
+    }
+  }
+
+  return st ? st
+            : (eat_byte_check(reader, q) ? SERD_SUCCESS : SERD_ERR_BAD_SYNTAX);
 }
 
 static SerdStatus
 read_String(SerdReader* reader, Ref node, SerdNodeFlags* flags)
 {
-	const int q1 = peek_byte(reader);
-	eat_byte_safe(reader, q1);
-
-	const int q2 = peek_byte(reader);
-	if (q2 == EOF) {
-		return r_err(reader, SERD_ERR_BAD_SYNTAX, "unexpected end of file\n");
-	}
-
-	if (q2 != q1) {  // Short string (not triple quoted)
-		return read_STRING_LITERAL(reader, node, flags, (uint8_t)q1);
-	}
-
-	eat_byte_safe(reader, q2);
-	const int q3 = peek_byte(reader);
-	if (q3 == EOF) {
-		return r_err(reader, SERD_ERR_BAD_SYNTAX, "unexpected end of file\n");
-	}
-
-	if (q3 != q1) {  // Empty short string ("" or '')
-		return SERD_SUCCESS;
-	}
-
-	if (!fancy_syntax(reader)) {
-		return r_err(reader, SERD_ERR_BAD_SYNTAX,
-		             "syntax does not support long literals\n");
-	}
-
-	eat_byte_safe(reader, q3);
-	return read_STRING_LITERAL_LONG(reader, node, flags, (uint8_t)q1);
+  const int q1 = peek_byte(reader);
+  eat_byte_safe(reader, q1);
+
+  const int q2 = peek_byte(reader);
+  if (q2 == EOF) {
+    return r_err(reader, SERD_ERR_BAD_SYNTAX, "unexpected end of file\n");
+  }
+
+  if (q2 != q1) { // Short string (not triple quoted)
+    return read_STRING_LITERAL(reader, node, flags, (uint8_t)q1);
+  }
+
+  eat_byte_safe(reader, q2);
+  const int q3 = peek_byte(reader);
+  if (q3 == EOF) {
+    return r_err(reader, SERD_ERR_BAD_SYNTAX, "unexpected end of file\n");
+  }
+
+  if (q3 != q1) { // Empty short string ("" or '')
+    return SERD_SUCCESS;
+  }
+
+  if (!fancy_syntax(reader)) {
+    return r_err(
+      reader, SERD_ERR_BAD_SYNTAX, "syntax does not support long literals\n");
+  }
+
+  eat_byte_safe(reader, q3);
+  return read_STRING_LITERAL_LONG(reader, node, flags, (uint8_t)q1);
 }
 
 static inline bool
 is_PN_CHARS_BASE(const uint32_t c)
 {
-	return ((c >= 0x00C0 && c <= 0x00D6) || (c >= 0x00D8 && c <= 0x00F6) ||
-	        (c >= 0x00F8 && c <= 0x02FF) || (c >= 0x0370 && c <= 0x037D) ||
-	        (c >= 0x037F && c <= 0x1FFF) || (c >= 0x200C && c <= 0x200D) ||
-	        (c >= 0x2070 && c <= 0x218F) || (c >= 0x2C00 && c <= 0x2FEF) ||
-	        (c >= 0x3001 && c <= 0xD7FF) || (c >= 0xF900 && c <= 0xFDCF) ||
-	        (c >= 0xFDF0 && c <= 0xFFFD) || (c >= 0x10000 && c <= 0xEFFFF));
+  return ((c >= 0x00C0 && c <= 0x00D6) || (c >= 0x00D8 && c <= 0x00F6) ||
+          (c >= 0x00F8 && c <= 0x02FF) || (c >= 0x0370 && c <= 0x037D) ||
+          (c >= 0x037F && c <= 0x1FFF) || (c >= 0x200C && c <= 0x200D) ||
+          (c >= 0x2070 && c <= 0x218F) || (c >= 0x2C00 && c <= 0x2FEF) ||
+          (c >= 0x3001 && c <= 0xD7FF) || (c >= 0xF900 && c <= 0xFDCF) ||
+          (c >= 0xFDF0 && c <= 0xFFFD) || (c >= 0x10000 && c <= 0xEFFFF));
 }
 
 static SerdStatus
 read_PN_CHARS_BASE(SerdReader* reader, Ref dest)
 {
-	uint32_t   code = 0;
-	const int  c    = peek_byte(reader);
-	SerdStatus st   = SERD_SUCCESS;
-	if (is_alpha(c)) {
-		push_byte(reader, dest, eat_byte_safe(reader, c));
-	} else if (c == EOF || !(c & 0x80)) {
-		return SERD_FAILURE;
-	} else if ((st = read_utf8_code(reader, dest, &code,
-	                                (uint8_t)eat_byte_safe(reader, c)))) {
-		return st;
-	} else if (!is_PN_CHARS_BASE(code)) {
-		r_err(reader, SERD_ERR_BAD_SYNTAX,
-		      "invalid character U+%04X in name\n", code);
-		if (reader->strict) {
-			return SERD_ERR_BAD_SYNTAX;
-		}
-	}
-	return st;
+  uint32_t   code = 0;
+  const int  c    = peek_byte(reader);
+  SerdStatus st   = SERD_SUCCESS;
+  if (is_alpha(c)) {
+    push_byte(reader, dest, eat_byte_safe(reader, c));
+  } else if (c == EOF || !(c & 0x80)) {
+    return SERD_FAILURE;
+  } else if ((st = read_utf8_code(
+                reader, dest, &code, (uint8_t)eat_byte_safe(reader, c)))) {
+    return st;
+  } else if (!is_PN_CHARS_BASE(code)) {
+    r_err(
+      reader, SERD_ERR_BAD_SYNTAX, "invalid character U+%04X in name\n", code);
+    if (reader->strict) {
+      return SERD_ERR_BAD_SYNTAX;
+    }
+  }
+  return st;
 }
 
 static inline bool
 is_PN_CHARS(const uint32_t c)
 {
-	return (is_PN_CHARS_BASE(c) || c == 0xB7 ||
-	        (c >= 0x0300 && c <= 0x036F) || (c >= 0x203F && c <= 0x2040));
+  return (is_PN_CHARS_BASE(c) || c == 0xB7 || (c >= 0x0300 && c <= 0x036F) ||
+          (c >= 0x203F && c <= 0x2040));
 }
 
 static SerdStatus
 read_PN_CHARS(SerdReader* reader, Ref dest)
 {
-	uint32_t   code = 0;
-	const int  c    = peek_byte(reader);
-	SerdStatus st   = SERD_SUCCESS;
-	if (is_alpha(c) || is_digit(c) || c == '_' || c == '-') {
-		push_byte(reader, dest, eat_byte_safe(reader, c));
-	} else if (c == EOF || !(c & 0x80)) {
-		return SERD_FAILURE;
-	} else if ((st = read_utf8_code(reader, dest, &code,
-	                                (uint8_t)eat_byte_safe(reader, c)))) {
-		return st;
-	} else if (!is_PN_CHARS(code)) {
-		return r_err(reader, SERD_ERR_BAD_SYNTAX,
-		             "invalid character U+%04X in name\n", code);
-	}
-	return st;
+  uint32_t   code = 0;
+  const int  c    = peek_byte(reader);
+  SerdStatus st   = SERD_SUCCESS;
+  if (is_alpha(c) || is_digit(c) || c == '_' || c == '-') {
+    push_byte(reader, dest, eat_byte_safe(reader, c));
+  } else if (c == EOF || !(c & 0x80)) {
+    return SERD_FAILURE;
+  } else if ((st = read_utf8_code(
+                reader, dest, &code, (uint8_t)eat_byte_safe(reader, c)))) {
+    return st;
+  } else if (!is_PN_CHARS(code)) {
+    return r_err(
+      reader, SERD_ERR_BAD_SYNTAX, "invalid character U+%04X in name\n", code);
+  }
+  return st;
 }
 
 static SerdStatus
 read_PERCENT(SerdReader* reader, Ref dest)
 {
-	push_byte(reader, dest, eat_byte_safe(reader, '%'));
-	const uint8_t h1 = read_HEX(reader);
-	const uint8_t h2 = read_HEX(reader);
-	if (h1 && h2) {
-		push_byte(reader, dest, h1);
-		return push_byte(reader, dest, h2);
-	}
-	return SERD_ERR_BAD_SYNTAX;
+  push_byte(reader, dest, eat_byte_safe(reader, '%'));
+  const uint8_t h1 = read_HEX(reader);
+  const uint8_t h2 = read_HEX(reader);
+  if (h1 && h2) {
+    push_byte(reader, dest, h1);
+    return push_byte(reader, dest, h2);
+  }
+
+  return SERD_ERR_BAD_SYNTAX;
 }
 
 static SerdStatus
 read_PN_LOCAL_ESC(SerdReader* reader, Ref dest)
 {
-	eat_byte_safe(reader, '\\');
-
-	const int c = peek_byte(reader);
-	switch (c) {
-	case '!':
-	case '#':
-	case '$':
-	case '%':
-	case '&':
-	case '\'':
-	case '(':
-	case ')':
-	case '*':
-	case '+':
-	case ',':
-	case '-':
-	case '.':
-	case '/':
-	case ';':
-	case '=':
-	case '?':
-	case '@':
-	case '_':
-	case '~':
-		push_byte(reader, dest, eat_byte_safe(reader, c));
-		break;
-	default:
-		return r_err(reader, SERD_ERR_BAD_SYNTAX, "invalid escape\n");
-	}
-
-	return SERD_SUCCESS;
+  eat_byte_safe(reader, '\\');
+
+  const int c = peek_byte(reader);
+  switch (c) {
+  case '!':
+  case '#':
+  case '$':
+  case '%':
+  case '&':
+  case '\'':
+  case '(':
+  case ')':
+  case '*':
+  case '+':
+  case ',':
+  case '-':
+  case '.':
+  case '/':
+  case ';':
+  case '=':
+  case '?':
+  case '@':
+  case '_':
+  case '~':
+    push_byte(reader, dest, eat_byte_safe(reader, c));
+    break;
+  default:
+    return r_err(reader, SERD_ERR_BAD_SYNTAX, "invalid escape\n");
+  }
+
+  return SERD_SUCCESS;
 }
 
 static SerdStatus
 read_PLX(SerdReader* reader, Ref dest)
 {
-	const int c = peek_byte(reader);
-	switch (c) {
-	case '%':
-		return read_PERCENT(reader, dest);
-	case '\\':
-		return read_PN_LOCAL_ESC(reader, dest);
-	default:
-		return SERD_FAILURE;
-	}
+  const int c = peek_byte(reader);
+  switch (c) {
+  case '%':
+    return read_PERCENT(reader, dest);
+  case '\\':
+    return read_PN_LOCAL_ESC(reader, dest);
+  default:
+    return SERD_FAILURE;
+  }
 }
 
 static SerdStatus
 read_PN_LOCAL(SerdReader* reader, Ref dest, bool* ate_dot)
 {
-	int        c                      = peek_byte(reader);
-	SerdStatus st                     = SERD_SUCCESS;
-	bool       trailing_unescaped_dot = false;
-	switch (c) {
-	case '0': case '1': case '2': case '3': case '4': case '5':
-	case '6': case '7': case '8': case '9': case ':': case '_':
-		push_byte(reader, dest, eat_byte_safe(reader, c));
-		break;
-	default:
-		if ((st = read_PLX(reader, dest)) > SERD_FAILURE) {
-			return r_err(reader, st, "bad escape\n");
-		} else if (st != SERD_SUCCESS && read_PN_CHARS_BASE(reader, dest)) {
-			return SERD_FAILURE;
-		}
-	}
-
-	while ((c = peek_byte(reader))) {  // Middle: (PN_CHARS | '.' | ':')*
-		if (c == '.' || c == ':') {
-			push_byte(reader, dest, eat_byte_safe(reader, c));
-		} else if ((st = read_PLX(reader, dest)) > SERD_FAILURE) {
-			return r_err(reader, SERD_ERR_BAD_SYNTAX, "bad escape\n");
-		} else if (st != SERD_SUCCESS && (st = read_PN_CHARS(reader, dest))) {
-			break;
-		}
-		trailing_unescaped_dot = (c == '.');
-	}
-
-	SerdNode* const n = deref(reader, dest);
-	if (trailing_unescaped_dot) {
-		// Ate trailing dot, pop it from stack/node and inform caller
-		--n->n_bytes;
-		serd_stack_pop(&reader->stack, 1);
-		*ate_dot = true;
-	}
-
-	return (st > SERD_FAILURE) ? st : SERD_SUCCESS;
+  int        c                      = peek_byte(reader);
+  SerdStatus st                     = SERD_SUCCESS;
+  bool       trailing_unescaped_dot = false;
+  switch (c) {
+  case '0':
+  case '1':
+  case '2':
+  case '3':
+  case '4':
+  case '5':
+  case '6':
+  case '7':
+  case '8':
+  case '9':
+  case ':':
+  case '_':
+    push_byte(reader, dest, eat_byte_safe(reader, c));
+    break;
+  default:
+    if ((st = read_PLX(reader, dest)) > SERD_FAILURE) {
+      return r_err(reader, st, "bad escape\n");
+    } else if (st != SERD_SUCCESS && read_PN_CHARS_BASE(reader, dest)) {
+      return SERD_FAILURE;
+    }
+  }
+
+  while ((c = peek_byte(reader))) { // Middle: (PN_CHARS | '.' | ':')*
+    if (c == '.' || c == ':') {
+      push_byte(reader, dest, eat_byte_safe(reader, c));
+    } else if ((st = read_PLX(reader, dest)) > SERD_FAILURE) {
+      return r_err(reader, SERD_ERR_BAD_SYNTAX, "bad escape\n");
+    } else if (st != SERD_SUCCESS && (st = read_PN_CHARS(reader, dest))) {
+      break;
+    }
+    trailing_unescaped_dot = (c == '.');
+  }
+
+  SerdNode* const n = deref(reader, dest);
+  if (trailing_unescaped_dot) {
+    // Ate trailing dot, pop it from stack/node and inform caller
+    --n->n_bytes;
+    serd_stack_pop(&reader->stack, 1);
+    *ate_dot = true;
+  }
+
+  return (st > SERD_FAILURE) ? st : SERD_SUCCESS;
 }
 
 // Read the remainder of a PN_PREFIX after some initial characters
 static SerdStatus
 read_PN_PREFIX_tail(SerdReader* reader, Ref dest)
 {
-	int c = 0;
-	while ((c = peek_byte(reader))) {  // Middle: (PN_CHARS | '.')*
-		if (c == '.') {
-			push_byte(reader, dest, eat_byte_safe(reader, c));
-		} else if (read_PN_CHARS(reader, dest)) {
-			break;
-		}
-	}
-
-	const SerdNode* const n = deref(reader, dest);
-	if (n->buf[n->n_bytes - 1] == '.' && read_PN_CHARS(reader, dest)) {
-		return r_err(reader, SERD_ERR_BAD_SYNTAX, "prefix ends with `.'\n");
-	}
-
-	return SERD_SUCCESS;
+  int c = 0;
+  while ((c = peek_byte(reader))) { // Middle: (PN_CHARS | '.')*
+    if (c == '.') {
+      push_byte(reader, dest, eat_byte_safe(reader, c));
+    } else if (read_PN_CHARS(reader, dest)) {
+      break;
+    }
+  }
+
+  const SerdNode* const n = deref(reader, dest);
+  if (n->buf[n->n_bytes - 1] == '.' && read_PN_CHARS(reader, dest)) {
+    return r_err(reader, SERD_ERR_BAD_SYNTAX, "prefix ends with `.'\n");
+  }
+
+  return SERD_SUCCESS;
 }
 
 static SerdStatus
 read_PN_PREFIX(SerdReader* reader, Ref dest)
 {
-	if (!read_PN_CHARS_BASE(reader, dest)) {
-		return read_PN_PREFIX_tail(reader, dest);
-	}
-	return SERD_FAILURE;
+  if (!read_PN_CHARS_BASE(reader, dest)) {
+    return read_PN_PREFIX_tail(reader, dest);
+  }
+
+  return SERD_FAILURE;
 }
 
 static SerdStatus
 read_LANGTAG(SerdReader* reader, Ref* dest)
 {
-	int c = peek_byte(reader);
-	if (!is_alpha(c)) {
-		return r_err(reader, SERD_ERR_BAD_SYNTAX, "unexpected `%c'\n", c);
-	}
-
-	*dest = push_node(reader, SERD_LITERAL, "", 0);
-
-	SerdStatus st = SERD_SUCCESS;
-	TRY(st, push_byte(reader, *dest, eat_byte_safe(reader, c)));
-	while ((c = peek_byte(reader)) && is_alpha(c)) {
-		TRY(st, push_byte(reader, *dest, eat_byte_safe(reader, c)));
-	}
-	while (peek_byte(reader) == '-') {
-		TRY(st, push_byte(reader, *dest, eat_byte_safe(reader, '-')));
-		while ((c = peek_byte(reader)) && (is_alpha(c) || is_digit(c))) {
-			TRY(st, push_byte(reader, *dest, eat_byte_safe(reader, c)));
-		}
-	}
-	return SERD_SUCCESS;
+  int c = peek_byte(reader);
+  if (!is_alpha(c)) {
+    return r_err(reader, SERD_ERR_BAD_SYNTAX, "unexpected `%c'\n", c);
+  }
+
+  *dest = push_node(reader, SERD_LITERAL, "", 0);
+
+  SerdStatus st = SERD_SUCCESS;
+  TRY(st, push_byte(reader, *dest, eat_byte_safe(reader, c)));
+  while ((c = peek_byte(reader)) && is_alpha(c)) {
+    TRY(st, push_byte(reader, *dest, eat_byte_safe(reader, c)));
+  }
+
+  while (peek_byte(reader) == '-') {
+    TRY(st, push_byte(reader, *dest, eat_byte_safe(reader, '-')));
+    while ((c = peek_byte(reader)) && (is_alpha(c) || is_digit(c))) {
+      TRY(st, push_byte(reader, *dest, eat_byte_safe(reader, c)));
+    }
+  }
+
+  return SERD_SUCCESS;
 }
 
 static SerdStatus
 read_IRIREF_scheme(SerdReader* reader, Ref dest)
 {
-	int c = peek_byte(reader);
-	if (!is_alpha(c)) {
-		return r_err(reader, SERD_ERR_BAD_SYNTAX,
-		             "bad IRI scheme start `%c'\n", c);
-	}
-
-	while ((c = peek_byte(reader)) != EOF) {
-		if (c == '>') {
-			return r_err(reader, SERD_ERR_BAD_SYNTAX, "missing IRI scheme\n");
-		}
-
-		if (!is_uri_scheme_char(c)) {
-			return r_err(reader, SERD_ERR_BAD_SYNTAX,
-			             "bad IRI scheme char U+%04X (%c)\n",
-			             (unsigned)c,
-			             (char)c);
-		}
-
-		push_byte(reader, dest, eat_byte_safe(reader, c));
-		if (c == ':') {
-			return SERD_SUCCESS;  // End of scheme
-		}
-	}
-
-	return r_err(reader, SERD_ERR_BAD_SYNTAX, "unexpected end of file\n");
+  int c = peek_byte(reader);
+  if (!is_alpha(c)) {
+    return r_err(reader, SERD_ERR_BAD_SYNTAX, "bad IRI scheme start `%c'\n", c);
+  }
+
+  while ((c = peek_byte(reader)) != EOF) {
+    if (c == '>') {
+      return r_err(reader, SERD_ERR_BAD_SYNTAX, "missing IRI scheme\n");
+    }
+
+    if (!is_uri_scheme_char(c)) {
+      return r_err(reader,
+                   SERD_ERR_BAD_SYNTAX,
+                   "bad IRI scheme char U+%04X (%c)\n",
+                   (unsigned)c,
+                   (char)c);
+    }
+
+    push_byte(reader, dest, eat_byte_safe(reader, c));
+    if (c == ':') {
+      return SERD_SUCCESS; // End of scheme
+    }
+  }
+
+  return r_err(reader, SERD_ERR_BAD_SYNTAX, "unexpected end of file\n");
 }
 
 static SerdStatus
 read_IRIREF(SerdReader* reader, Ref* dest)
 {
-	if (!eat_byte_check(reader, '<')) {
-		return SERD_ERR_BAD_SYNTAX;
-	}
-
-	*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");
-	}
-
-	SerdStatus st   = SERD_SUCCESS;
-	uint32_t   code = 0;
-	while (!st) {
-		const int c = eat_byte_safe(reader, peek_byte(reader));
-		switch (c) {
-		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:
-				break;
-			}
-			break;
-		case '^':
-		case '`':
-		case '{':
-		case '|':
-		case '}':
-			*dest = pop_node(reader, *dest);
-			return r_err(reader, SERD_ERR_BAD_SYNTAX,
-			             "invalid IRI character `%c'\n", c);
-		default:
-			if (c <= 0x20) {
-				r_err(reader, SERD_ERR_BAD_SYNTAX,
-				      "invalid IRI character (escape %%%02X)\n",
-				      (unsigned)c);
-				if (reader->strict) {
-					*dest = pop_node(reader, *dest);
-					return SERD_ERR_BAD_SYNTAX;
-				}
-				st = SERD_FAILURE;
-				push_byte(reader, *dest, c);
-			} else if (!(c & 0x80)) {
-				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;
+  if (!eat_byte_check(reader, '<')) {
+    return SERD_ERR_BAD_SYNTAX;
+  }
+
+  *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");
+  }
+
+  SerdStatus st   = SERD_SUCCESS;
+  uint32_t   code = 0;
+  while (!st) {
+    const int c = eat_byte_safe(reader, peek_byte(reader));
+    switch (c) {
+    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:
+        break;
+      }
+      break;
+
+    case '^':
+    case '`':
+    case '{':
+    case '|':
+    case '}':
+      *dest = pop_node(reader, *dest);
+      return r_err(
+        reader, SERD_ERR_BAD_SYNTAX, "invalid IRI character `%c'\n", c);
+
+    default:
+      if (c <= 0x20) {
+        r_err(reader,
+              SERD_ERR_BAD_SYNTAX,
+              "invalid IRI character (escape %%%02X)\n",
+              (unsigned)c);
+        if (reader->strict) {
+          *dest = pop_node(reader, *dest);
+          return SERD_ERR_BAD_SYNTAX;
+        }
+        st = SERD_FAILURE;
+        push_byte(reader, *dest, c);
+      } else if (!(c & 0x80)) {
+        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;
 }
 
 static SerdStatus
 read_PrefixedName(SerdReader* reader, Ref dest, bool read_prefix, bool* ate_dot)
 {
-	SerdStatus st = SERD_SUCCESS;
-	if (read_prefix && ((st = read_PN_PREFIX(reader, dest)) > SERD_FAILURE)) {
-		return st;
-	}
+  SerdStatus st = SERD_SUCCESS;
+  if (read_prefix && ((st = read_PN_PREFIX(reader, dest)) > SERD_FAILURE)) {
+    return st;
+  }
 
-	if (peek_byte(reader) != ':') {
-		return SERD_FAILURE;
-	}
+  if (peek_byte(reader) != ':') {
+    return SERD_FAILURE;
+  }
 
-	push_byte(reader, dest, eat_byte_safe(reader, ':'));
+  push_byte(reader, dest, eat_byte_safe(reader, ':'));
 
-	st = read_PN_LOCAL(reader, dest, ate_dot);
+  st = read_PN_LOCAL(reader, dest, ate_dot);
 
-	return (st > SERD_FAILURE) ? st : SERD_SUCCESS;
+  return (st > SERD_FAILURE) ? st : SERD_SUCCESS;
 }
 
 static SerdStatus
 read_0_9(SerdReader* reader, Ref str, bool at_least_one)
 {
-	unsigned   count = 0;
-	SerdStatus st    = SERD_SUCCESS;
-	for (int c = 0; is_digit((c = peek_byte(reader))); ++count) {
-		TRY(st, push_byte(reader, str, eat_byte_safe(reader, c)));
-	}
-	if (at_least_one && count == 0) {
-		return r_err(reader, SERD_ERR_BAD_SYNTAX, "expected digit\n");
-	}
-	return SERD_SUCCESS;
+  unsigned   count = 0;
+  SerdStatus st    = SERD_SUCCESS;
+  for (int c = 0; is_digit((c = peek_byte(reader))); ++count) {
+    TRY(st, push_byte(reader, str, eat_byte_safe(reader, c)));
+  }
+
+  if (at_least_one && count == 0) {
+    return r_err(reader, SERD_ERR_BAD_SYNTAX, "expected digit\n");
+  }
+
+  return SERD_SUCCESS;
 }
 
 static SerdStatus
 read_number(SerdReader* reader, Ref* dest, Ref* datatype, bool* ate_dot)
 {
-	#define XSD_DECIMAL NS_XSD "decimal"
-	#define XSD_DOUBLE  NS_XSD "double"
-	#define XSD_INTEGER NS_XSD "integer"
-
-	*dest = push_node(reader, SERD_LITERAL, "", 0);
-
-	SerdStatus st          = SERD_SUCCESS;
-	int        c           = peek_byte(reader);
-	bool       has_decimal = false;
-	if (c == '-' || c == '+') {
-		push_byte(reader, *dest, eat_byte_safe(reader, c));
-	}
-	if ((c = peek_byte(reader)) == '.') {
-		has_decimal = true;
-		// decimal case 2 (e.g. '.0' or `-.0' or `+.0')
-		push_byte(reader, *dest, eat_byte_safe(reader, c));
-		TRY(st, read_0_9(reader, *dest, true));
-	} else {
-		// all other cases ::= ( '-' | '+' ) [0-9]+ ( . )? ( [0-9]+ )? ...
-		TRY(st, read_0_9(reader, *dest, true));
-		if ((c = peek_byte(reader)) == '.') {
-			has_decimal = true;
-
-			// Annoyingly, dot can be end of statement, so tentatively eat
-			eat_byte_safe(reader, c);
-			c = peek_byte(reader);
-			if (!is_digit(c) && c != 'e' && c != 'E') {
-				*ate_dot = true;  // Force caller to deal with stupid grammar
-				return SERD_SUCCESS;  // Next byte is not a number character
-			}
-
-			push_byte(reader, *dest, '.');
-			read_0_9(reader, *dest, false);
-		}
-	}
-	c = peek_byte(reader);
-	if (c == 'e' || c == 'E') {
-		// double
-		push_byte(reader, *dest, eat_byte_safe(reader, c));
-		switch ((c = peek_byte(reader))) {
-		case '+': case '-':
-			push_byte(reader, *dest, eat_byte_safe(reader, c));
-		default: break;
-		}
-		TRY(st, read_0_9(reader, *dest, true));
-		*datatype = push_node(reader, SERD_URI,
-		                      XSD_DOUBLE, sizeof(XSD_DOUBLE) - 1);
-	} else if (has_decimal) {
-		*datatype = push_node(reader, SERD_URI,
-		                      XSD_DECIMAL, sizeof(XSD_DECIMAL) - 1);
-	} else {
-		*datatype = push_node(reader, SERD_URI,
-		                      XSD_INTEGER, sizeof(XSD_INTEGER) - 1);
-	}
-
-	return SERD_SUCCESS;
+#define XSD_DECIMAL NS_XSD "decimal"
+#define XSD_DOUBLE NS_XSD "double"
+#define XSD_INTEGER NS_XSD "integer"
+
+  *dest = push_node(reader, SERD_LITERAL, "", 0);
+
+  SerdStatus st          = SERD_SUCCESS;
+  int        c           = peek_byte(reader);
+  bool       has_decimal = false;
+  if (c == '-' || c == '+') {
+    push_byte(reader, *dest, eat_byte_safe(reader, c));
+  }
+  if ((c = peek_byte(reader)) == '.') {
+    has_decimal = true;
+    // decimal case 2 (e.g. '.0' or `-.0' or `+.0')
+    push_byte(reader, *dest, eat_byte_safe(reader, c));
+    TRY(st, read_0_9(reader, *dest, true));
+  } else {
+    // all other cases ::= ( '-' | '+' ) [0-9]+ ( . )? ( [0-9]+ )? ...
+    TRY(st, read_0_9(reader, *dest, true));
+    if ((c = peek_byte(reader)) == '.') {
+      has_decimal = true;
+
+      // Annoyingly, dot can be end of statement, so tentatively eat
+      eat_byte_safe(reader, c);
+      c = peek_byte(reader);
+      if (!is_digit(c) && c != 'e' && c != 'E') {
+        *ate_dot = true;     // Force caller to deal with stupid grammar
+        return SERD_SUCCESS; // Next byte is not a number character
+      }
+
+      push_byte(reader, *dest, '.');
+      read_0_9(reader, *dest, false);
+    }
+  }
+  c = peek_byte(reader);
+  if (c == 'e' || c == 'E') {
+    // double
+    push_byte(reader, *dest, eat_byte_safe(reader, c));
+    switch ((c = peek_byte(reader))) {
+    case '+':
+    case '-':
+      push_byte(reader, *dest, eat_byte_safe(reader, c));
+    default:
+      break;
+    }
+    TRY(st, read_0_9(reader, *dest, true));
+    *datatype = push_node(reader, SERD_URI, XSD_DOUBLE, sizeof(XSD_DOUBLE) - 1);
+  } else if (has_decimal) {
+    *datatype =
+      push_node(reader, SERD_URI, XSD_DECIMAL, sizeof(XSD_DECIMAL) - 1);
+  } else {
+    *datatype =
+      push_node(reader, SERD_URI, XSD_INTEGER, sizeof(XSD_INTEGER) - 1);
+  }
+
+  return SERD_SUCCESS;
 }
 
 static SerdStatus
 read_iri(SerdReader* reader, Ref* dest, bool* ate_dot)
 {
-	switch (peek_byte(reader)) {
-	case '<':
-		return read_IRIREF(reader, dest);
-	default:
-		*dest = push_node(reader, SERD_CURIE, "", 0);
-		return read_PrefixedName(reader, *dest, true, ate_dot);
-	}
+  switch (peek_byte(reader)) {
+  case '<':
+    return read_IRIREF(reader, dest);
+  default:
+    *dest = push_node(reader, SERD_CURIE, "", 0);
+    return read_PrefixedName(reader, *dest, true, ate_dot);
+  }
 }
 
 static SerdStatus
-read_literal(SerdReader* reader, Ref* dest,
-             Ref* datatype, Ref* lang, SerdNodeFlags* flags, bool* ate_dot)
+read_literal(SerdReader*    reader,
+             Ref*           dest,
+             Ref*           datatype,
+             Ref*           lang,
+             SerdNodeFlags* flags,
+             bool*          ate_dot)
 {
-	*dest = push_node(reader, SERD_LITERAL, "", 0);
-
-	SerdStatus st = read_String(reader, *dest, flags);
-	if (st) {
-		*dest = pop_node(reader, *dest);
-		return st;
-	}
-
-	switch (peek_byte(reader)) {
-	case '@':
-		eat_byte_safe(reader, '@');
-		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;
-	case '^':
-		eat_byte_safe(reader, '^');
-		eat_byte_check(reader, '^');
-		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;
-	}
-	return SERD_SUCCESS;
+  *dest = push_node(reader, SERD_LITERAL, "", 0);
+
+  SerdStatus st = read_String(reader, *dest, flags);
+  if (st) {
+    *dest = pop_node(reader, *dest);
+    return st;
+  }
+
+  switch (peek_byte(reader)) {
+  case '@':
+    eat_byte_safe(reader, '@');
+    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;
+  case '^':
+    eat_byte_safe(reader, '^');
+    eat_byte_check(reader, '^');
+    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;
+  }
+
+  return SERD_SUCCESS;
 }
 
 static SerdStatus
 read_verb(SerdReader* reader, Ref* dest)
 {
-	if (peek_byte(reader) == '<') {
-		return read_IRIREF(reader, dest);
-	}
-
-	/* Either a qname, or "a".  Read the prefix first, and if it is in fact
-	   "a", produce that instead.
-	*/
-	*dest = push_node(reader, SERD_CURIE, "", 0);
-
-	SerdStatus st      = read_PN_PREFIX(reader, *dest);
-	bool       ate_dot = false;
-	SerdNode*  node    = deref(reader, *dest);
-	const int  next    = peek_byte(reader);
-	if (!st && node->n_bytes == 1 && node->buf[0] == 'a' &&
-	    next != ':' && !is_PN_CHARS_BASE((uint32_t)next)) {
-		pop_node(reader, *dest);
-		*dest = push_node(reader, SERD_URI, NS_RDF "type", 47);
-		return SERD_SUCCESS;
-	}
-
-	if (st > SERD_FAILURE ||
-	    read_PrefixedName(reader, *dest, false, &ate_dot) ||
-	    ate_dot) {
-		*dest = pop_node(reader, *dest);
-		return r_err(reader, SERD_ERR_BAD_SYNTAX, "bad verb\n");
-	}
-
-	return SERD_SUCCESS;
+  if (peek_byte(reader) == '<') {
+    return read_IRIREF(reader, dest);
+  }
+
+  /* Either a qname, or "a".  Read the prefix first, and if it is in fact
+     "a", produce that instead.
+  */
+  *dest = push_node(reader, SERD_CURIE, "", 0);
+
+  SerdStatus st      = read_PN_PREFIX(reader, *dest);
+  bool       ate_dot = false;
+  SerdNode*  node    = deref(reader, *dest);
+  const int  next    = peek_byte(reader);
+  if (!st && node->n_bytes == 1 && node->buf[0] == 'a' && next != ':' &&
+      !is_PN_CHARS_BASE((uint32_t)next)) {
+    pop_node(reader, *dest);
+    *dest = push_node(reader, SERD_URI, NS_RDF "type", 47);
+    return SERD_SUCCESS;
+  }
+
+  if (st > SERD_FAILURE || read_PrefixedName(reader, *dest, false, &ate_dot) ||
+      ate_dot) {
+    *dest = pop_node(reader, *dest);
+    return r_err(reader, SERD_ERR_BAD_SYNTAX, "bad verb\n");
+  }
+
+  return SERD_SUCCESS;
 }
 
 static SerdStatus
 read_BLANK_NODE_LABEL(SerdReader* reader, Ref* dest, bool* ate_dot)
 {
-	eat_byte_safe(reader, '_');
-	eat_byte_check(reader, ':');
-
-	const Ref ref = *dest =
-	    push_node(reader,
-	              SERD_BLANK,
-	              reader->bprefix ? (char*)reader->bprefix : "",
-	              reader->bprefix_len);
-
-	int c = peek_byte(reader);  // First: (PN_CHARS | '_' | [0-9])
-	if (is_digit(c) || c == '_') {
-		push_byte(reader, ref, eat_byte_safe(reader, c));
-	} else if (read_PN_CHARS(reader, ref)) {
-		*dest = pop_node(reader, *dest);
-		return r_err(reader, SERD_ERR_BAD_SYNTAX, "invalid name start\n");
-	}
-
-	while ((c = peek_byte(reader))) {  // Middle: (PN_CHARS | '.')*
-		if (c == '.') {
-			push_byte(reader, ref, eat_byte_safe(reader, c));
-		} else if (read_PN_CHARS(reader, ref)) {
-			break;
-		}
-	}
-
-	SerdNode* n = deref(reader, ref);
-	if (n->buf[n->n_bytes - 1] == '.' && read_PN_CHARS(reader, ref)) {
-		// Ate trailing dot, pop it from stack/node and inform caller
-		--n->n_bytes;
-		serd_stack_pop(&reader->stack, 1);
-		*ate_dot = true;
-	}
-
-	if (fancy_syntax(reader)) {
-		if (is_digit(n->buf[reader->bprefix_len + 1])) {
-			if ((n->buf[reader->bprefix_len]) == 'b') {
-				((char*)n->buf)[reader->bprefix_len] = 'B';  // Prevent clash
-				reader->seen_genid = true;
-			} else if (reader->seen_genid &&
-			           n->buf[reader->bprefix_len] == 'B') {
-				*dest = pop_node(reader, *dest);
-				return r_err(
-					reader, SERD_ERR_ID_CLASH,
-					"found both `b' and `B' blank IDs, prefix required\n");
-			}
-		}
-	}
-	return SERD_SUCCESS;
+  eat_byte_safe(reader, '_');
+  eat_byte_check(reader, ':');
+
+  const Ref ref = *dest =
+    push_node(reader,
+              SERD_BLANK,
+              reader->bprefix ? (char*)reader->bprefix : "",
+              reader->bprefix_len);
+
+  int c = peek_byte(reader); // First: (PN_CHARS | '_' | [0-9])
+  if (is_digit(c) || c == '_') {
+    push_byte(reader, ref, eat_byte_safe(reader, c));
+  } else if (read_PN_CHARS(reader, ref)) {
+    *dest = pop_node(reader, *dest);
+    return r_err(reader, SERD_ERR_BAD_SYNTAX, "invalid name start\n");
+  }
+
+  while ((c = peek_byte(reader))) { // Middle: (PN_CHARS | '.')*
+    if (c == '.') {
+      push_byte(reader, ref, eat_byte_safe(reader, c));
+    } else if (read_PN_CHARS(reader, ref)) {
+      break;
+    }
+  }
+
+  SerdNode* n = deref(reader, ref);
+  if (n->buf[n->n_bytes - 1] == '.' && read_PN_CHARS(reader, ref)) {
+    // Ate trailing dot, pop it from stack/node and inform caller
+    --n->n_bytes;
+    serd_stack_pop(&reader->stack, 1);
+    *ate_dot = true;
+  }
+
+  if (fancy_syntax(reader)) {
+    if (is_digit(n->buf[reader->bprefix_len + 1])) {
+      if ((n->buf[reader->bprefix_len]) == 'b') {
+        ((char*)n->buf)[reader->bprefix_len] = 'B'; // Prevent clash
+        reader->seen_genid                   = true;
+      } else if (reader->seen_genid && n->buf[reader->bprefix_len] == 'B') {
+        *dest = pop_node(reader, *dest);
+        return r_err(reader,
+                     SERD_ERR_ID_CLASH,
+                     "found both `b' and `B' blank IDs, prefix required\n");
+      }
+    }
+  }
+
+  return SERD_SUCCESS;
 }
 
 static Ref
 read_blankName(SerdReader* reader)
 {
-	eat_byte_safe(reader, '=');
-	if (eat_byte_check(reader, '=') != '=') {
-		r_err(reader, SERD_ERR_BAD_SYNTAX, "expected `='\n");
-		return 0;
-	}
-
-	Ref  subject = 0;
-	bool ate_dot = false;
-	read_ws_star(reader);
-	read_iri(reader, &subject, &ate_dot);
-	return subject;
+  eat_byte_safe(reader, '=');
+  if (eat_byte_check(reader, '=') != '=') {
+    r_err(reader, SERD_ERR_BAD_SYNTAX, "expected `='\n");
+    return 0;
+  }
+
+  Ref  subject = 0;
+  bool ate_dot = false;
+  read_ws_star(reader);
+  read_iri(reader, &subject, &ate_dot);
+  return subject;
 }
 
 static SerdStatus
 read_anon(SerdReader* reader, ReadContext ctx, bool subject, Ref* dest)
 {
-	const SerdStatementFlags old_flags = *ctx.flags;
-	bool                     empty     = false;
-	eat_byte_safe(reader, '[');
-	if ((empty = peek_delim(reader, ']'))) {
-		*ctx.flags |= (subject) ? SERD_EMPTY_S : SERD_EMPTY_O;
-	} else {
-		*ctx.flags |= (subject) ? SERD_ANON_S_BEGIN : SERD_ANON_O_BEGIN;
-		if (peek_delim(reader, '=')) {
-			if (!(*dest = read_blankName(reader)) ||
-			    !eat_delim(reader, ';')) {
-				return SERD_ERR_BAD_SYNTAX;
-			}
-		}
-	}
-
-	if (!*dest) {
-		*dest = blank_id(reader);
-	}
-
-	SerdStatus st = SERD_SUCCESS;
-	if (ctx.subject) {
-		TRY(st, emit_statement(reader, ctx, *dest, 0, 0));
-	}
-
-	ctx.subject = *dest;
-	if (!empty) {
-		*ctx.flags &= ~(unsigned)SERD_LIST_CONT;
-		if (!subject) {
-			*ctx.flags |= SERD_ANON_CONT;
-		}
-		bool ate_dot_in_list = false;
-		read_predicateObjectList(reader, ctx, &ate_dot_in_list);
-		if (ate_dot_in_list) {
-			return r_err(reader, SERD_ERR_BAD_SYNTAX, "`.' inside blank\n");
-		}
-		read_ws_star(reader);
-		if (reader->end_sink) {
-			reader->end_sink(reader->handle, deref(reader, *dest));
-		}
-		*ctx.flags = old_flags;
-	}
-	return (eat_byte_check(reader, ']') == ']') ? SERD_SUCCESS
-	                                            : SERD_ERR_BAD_SYNTAX;
+  const SerdStatementFlags old_flags = *ctx.flags;
+  bool                     empty     = false;
+  eat_byte_safe(reader, '[');
+  if ((empty = peek_delim(reader, ']'))) {
+    *ctx.flags |= (subject) ? SERD_EMPTY_S : SERD_EMPTY_O;
+  } else {
+    *ctx.flags |= (subject) ? SERD_ANON_S_BEGIN : SERD_ANON_O_BEGIN;
+    if (peek_delim(reader, '=')) {
+      if (!(*dest = read_blankName(reader)) || !eat_delim(reader, ';')) {
+        return SERD_ERR_BAD_SYNTAX;
+      }
+    }
+  }
+
+  if (!*dest) {
+    *dest = blank_id(reader);
+  }
+
+  SerdStatus st = SERD_SUCCESS;
+  if (ctx.subject) {
+    TRY(st, emit_statement(reader, ctx, *dest, 0, 0));
+  }
+
+  ctx.subject = *dest;
+  if (!empty) {
+    *ctx.flags &= ~(unsigned)SERD_LIST_CONT;
+    if (!subject) {
+      *ctx.flags |= SERD_ANON_CONT;
+    }
+
+    bool ate_dot_in_list = false;
+    read_predicateObjectList(reader, ctx, &ate_dot_in_list);
+    if (ate_dot_in_list) {
+      return r_err(reader, SERD_ERR_BAD_SYNTAX, "`.' inside blank\n");
+    }
+
+    read_ws_star(reader);
+    if (reader->end_sink) {
+      reader->end_sink(reader->handle, deref(reader, *dest));
+    }
+
+    *ctx.flags = old_flags;
+  }
+
+  return (eat_byte_check(reader, ']') == ']') ? SERD_SUCCESS
+                                              : SERD_ERR_BAD_SYNTAX;
 }
 
 /* If emit is true: recurses, calling statement_sink for every statement
@@ -1050,593 +1100,621 @@ read_anon(SerdReader* reader, ReadContext ctx, bool subject, Ref* dest)
 static SerdStatus
 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;
+  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;
+  const size_t orig_stack_size = reader->stack.size;
 #endif
 
-	SerdStatus ret = SERD_FAILURE;
-
-	bool      simple   = (ctx->subject != 0);
-	SerdNode* node     = NULL;
-	Ref       o        = 0;
-	Ref       datatype = 0;
-	Ref       lang     = 0;
-	uint32_t  flags    = 0;
-	const int c        = peek_byte(reader);
-	if (!fancy_syntax(reader)) {
-		switch (c) {
-		case '"': case ':': case '<': case '_': break;
-		default:
-			return r_err(reader, SERD_ERR_BAD_SYNTAX,
-			             "expected: ':', '<', or '_'\n");
-		}
-	}
-	switch (c) {
-	case EOF: case ')':
-		return r_err(reader, SERD_ERR_BAD_SYNTAX, "expected object\n");
-	case '[':
-		simple = false;
-		ret = read_anon(reader, *ctx, false, &o);
-		break;
-	case '(':
-		simple = false;
-		ret = read_collection(reader, *ctx, &o);
-		break;
-	case '_':
-		ret = read_BLANK_NODE_LABEL(reader, &o, ate_dot);
-		break;
-	case '<': case ':':
-		ret = read_iri(reader, &o, ate_dot);
-		break;
-	case '+': case '-': case '.': case '0': case '1': case '2': case '3':
-	case '4': case '5': case '6': case '7': case '8': case '9':
-		ret = read_number(reader, &o, &datatype, ate_dot);
-		break;
-	case '\"':
-	case '\'':
-		ret = read_literal(reader, &o, &datatype, &lang, &flags, ate_dot);
-		break;
-	default:
-		/* Either a boolean literal, or a qname.  Read the prefix first, and if
-		   it is in fact a "true" or "false" literal, produce that instead.
-		*/
-		o = push_node(reader, SERD_CURIE, "", 0);
-		while (!read_PN_CHARS_BASE(reader, o)) {}
-		node = deref(reader, o);
-		if ((node->n_bytes == 4 && !memcmp(node->buf, "true", 4)) ||
-		    (node->n_bytes == 5 && !memcmp(node->buf, "false", 5))) {
-			node->type = SERD_LITERAL;
-			datatype   = push_node(
-				reader, SERD_URI, XSD_BOOLEAN, XSD_BOOLEAN_LEN);
-			ret = SERD_SUCCESS;
-		} else if (read_PN_PREFIX_tail(reader, o) > SERD_FAILURE) {
-			ret = SERD_ERR_BAD_SYNTAX;
-		} 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");
-			}
-		}
-	}
-
-	if (!ret && simple && o) {
-		deref(reader, o)->flags = flags;
-	}
-
-	if (!ret && emit && simple) {
-		ret = emit_statement(reader, *ctx, o, datatype, lang);
-	} else if (!ret && !emit) {
-		ctx->object   = o;
-		ctx->datatype = datatype;
-		ctx->lang     = lang;
-		return SERD_SUCCESS;
-	}
-
-	pop_node(reader, lang);
-	pop_node(reader, datatype);
-	pop_node(reader, o);
+  SerdStatus ret = SERD_FAILURE;
+
+  bool      simple   = (ctx->subject != 0);
+  SerdNode* node     = NULL;
+  Ref       o        = 0;
+  Ref       datatype = 0;
+  Ref       lang     = 0;
+  uint32_t  flags    = 0;
+  const int c        = peek_byte(reader);
+  if (!fancy_syntax(reader)) {
+    switch (c) {
+    case '"':
+    case ':':
+    case '<':
+    case '_':
+      break;
+    default:
+      return r_err(reader, SERD_ERR_BAD_SYNTAX, "expected: ':', '<', or '_'\n");
+    }
+  }
+  switch (c) {
+  case EOF:
+  case ')':
+    return r_err(reader, SERD_ERR_BAD_SYNTAX, "expected object\n");
+  case '[':
+    simple = false;
+    ret    = read_anon(reader, *ctx, false, &o);
+    break;
+  case '(':
+    simple = false;
+    ret    = read_collection(reader, *ctx, &o);
+    break;
+  case '_':
+    ret = read_BLANK_NODE_LABEL(reader, &o, ate_dot);
+    break;
+  case '<':
+  case ':':
+    ret = read_iri(reader, &o, ate_dot);
+    break;
+  case '+':
+  case '-':
+  case '.':
+  case '0':
+  case '1':
+  case '2':
+  case '3':
+  case '4':
+  case '5':
+  case '6':
+  case '7':
+  case '8':
+  case '9':
+    ret = read_number(reader, &o, &datatype, ate_dot);
+    break;
+  case '\"':
+  case '\'':
+    ret = read_literal(reader, &o, &datatype, &lang, &flags, ate_dot);
+    break;
+  default:
+    /* Either a boolean literal, or a qname.  Read the prefix first, and if
+       it is in fact a "true" or "false" literal, produce that instead.
+    */
+    o = push_node(reader, SERD_CURIE, "", 0);
+    while (!read_PN_CHARS_BASE(reader, o)) {
+    }
+    node = deref(reader, o);
+    if ((node->n_bytes == 4 && !memcmp(node->buf, "true", 4)) ||
+        (node->n_bytes == 5 && !memcmp(node->buf, "false", 5))) {
+      node->type = SERD_LITERAL;
+      datatype   = push_node(reader, SERD_URI, XSD_BOOLEAN, XSD_BOOLEAN_LEN);
+      ret        = SERD_SUCCESS;
+    } else if (read_PN_PREFIX_tail(reader, o) > SERD_FAILURE) {
+      ret = SERD_ERR_BAD_SYNTAX;
+    } 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");
+      }
+    }
+  }
+
+  if (!ret && simple && o) {
+    deref(reader, o)->flags = flags;
+  }
+
+  if (!ret && emit && simple) {
+    ret = emit_statement(reader, *ctx, o, datatype, lang);
+  } else if (!ret && !emit) {
+    ctx->object   = o;
+    ctx->datatype = datatype;
+    ctx->lang     = lang;
+    return SERD_SUCCESS;
+  }
+
+  pop_node(reader, lang);
+  pop_node(reader, datatype);
+  pop_node(reader, o);
 #ifndef NDEBUG
-	assert(reader->stack.size == orig_stack_size);
+  assert(reader->stack.size == orig_stack_size);
 #endif
-	return ret;
+  return ret;
 }
 
 static SerdStatus
 read_objectList(SerdReader* reader, ReadContext ctx, bool* ate_dot)
 {
-	SerdStatus st = SERD_SUCCESS;
-	TRY(st, read_object(reader, &ctx, true, ate_dot));
-	if (!fancy_syntax(reader) && peek_delim(reader, ',')) {
-		return r_err(reader, SERD_ERR_BAD_SYNTAX,
-		             "syntax does not support abbreviation\n");
-	}
-
-	while (!*ate_dot && eat_delim(reader, ',')) {
-		st = read_object(reader, &ctx, true, ate_dot);
-	}
-	return st;
+  SerdStatus st = SERD_SUCCESS;
+  TRY(st, read_object(reader, &ctx, true, ate_dot));
+  if (!fancy_syntax(reader) && peek_delim(reader, ',')) {
+    return r_err(
+      reader, SERD_ERR_BAD_SYNTAX, "syntax does not support abbreviation\n");
+  }
+
+  while (!*ate_dot && eat_delim(reader, ',')) {
+    st = read_object(reader, &ctx, true, ate_dot);
+  }
+
+  return st;
 }
 
 static SerdStatus
 read_predicateObjectList(SerdReader* reader, ReadContext ctx, bool* ate_dot)
 {
-	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) {
-			return SERD_SUCCESS;
-		}
-
-		bool ate_semi = false;
-		int  c        = 0;
-		do {
-			read_ws_star(reader);
-			switch (c = peek_byte(reader)) {
-			case EOF:
-				return r_err(reader, SERD_ERR_BAD_SYNTAX,
-				             "unexpected end of file\n");
-			case '.': case ']': case '}':
-				return SERD_SUCCESS;
-			case ';':
-				eat_byte_safe(reader, c);
-				ate_semi = true;
-			}
-		} while (c == ';');
-
-		if (!ate_semi) {
-			return r_err(reader, SERD_ERR_BAD_SYNTAX, "missing ';' or '.'\n");
-		}
-	}
-
-	ctx.predicate = pop_node(reader, ctx.predicate);
-	return st;
+  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) {
+      return SERD_SUCCESS;
+    }
+
+    bool ate_semi = false;
+    int  c        = 0;
+    do {
+      read_ws_star(reader);
+      switch (c = peek_byte(reader)) {
+      case EOF:
+        return r_err(reader, SERD_ERR_BAD_SYNTAX, "unexpected end of file\n");
+      case '.':
+      case ']':
+      case '}':
+        return SERD_SUCCESS;
+      case ';':
+        eat_byte_safe(reader, c);
+        ate_semi = true;
+      }
+    } while (c == ';');
+
+    if (!ate_semi) {
+      return r_err(reader, SERD_ERR_BAD_SYNTAX, "missing ';' or '.'\n");
+    }
+  }
+
+  ctx.predicate = pop_node(reader, ctx.predicate);
+  return st;
 }
 
 static SerdStatus
-end_collection(SerdReader* reader, ReadContext ctx, Ref n1, Ref n2, SerdStatus st)
+end_collection(SerdReader* reader,
+               ReadContext ctx,
+               Ref         n1,
+               Ref         n2,
+               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
-		                                            : SERD_ERR_BAD_SYNTAX;
-	}
-	return st;
+  pop_node(reader, n2);
+  pop_node(reader, n1);
+  *ctx.flags &= ~(unsigned)SERD_LIST_CONT;
+  if (!st) {
+    return (eat_byte_check(reader, ')') == ')') ? SERD_SUCCESS
+                                                : SERD_ERR_BAD_SYNTAX;
+  }
+
+  return st;
 }
 
 static SerdStatus
 read_collection(SerdReader* reader, ReadContext ctx, Ref* dest)
 {
-	SerdStatus st = SERD_SUCCESS;
-	eat_byte_safe(reader, '(');
-	bool end = peek_delim(reader, ')');
-	*dest = end ? reader->rdf_nil : blank_id(reader);
-	if (ctx.subject) {
-		// subject predicate _:head
-		*ctx.flags |= (end ? 0 : SERD_LIST_O_BEGIN);
-		TRY(st, emit_statement(reader, ctx, *dest, 0, 0));
-		*ctx.flags |= SERD_LIST_CONT;
-	} else {
-		*ctx.flags |= (end ? 0 : SERD_LIST_S_BEGIN);
-	}
-
-	if (end) {
-		return end_collection(reader, ctx, 0, 0, st);
-	}
-
-	/* The order of node allocation here is necessarily not in stack order,
-	   so we create two nodes and recycle them throughout. */
-	Ref n1   = push_node_padded(reader, genid_size(reader), SERD_BLANK, "", 0);
-	Ref n2   = 0;
-	Ref node = n1;
-	Ref rest = 0;
-
-	ctx.subject = *dest;
-	while (!peek_delim(reader, ')')) {
-		// _:node rdf:first object
-		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);
-		}
-
-		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
-			} else {
-				set_blank_id(reader, rest, genid_size(reader));
-			}
-		}
-
-		// _:node rdf:rest _:rest
-		*ctx.flags |= SERD_LIST_CONT;
-		ctx.predicate = reader->rdf_rest;
-		TRY(st, emit_statement(reader, ctx,
-		                       (end ? reader->rdf_nil : rest), 0, 0));
-
-		ctx.subject = rest;         // _:node = _:rest
-		rest        = node;         // _:rest = (old)_:node
-		node        = ctx.subject;  // invariant
-	}
-
-	return end_collection(reader, ctx, n1, n2, st);
+  SerdStatus st = SERD_SUCCESS;
+  eat_byte_safe(reader, '(');
+
+  bool end = peek_delim(reader, ')');
+
+  *dest = end ? reader->rdf_nil : blank_id(reader);
+  if (ctx.subject) {
+    // subject predicate _:head
+    *ctx.flags |= (end ? 0 : SERD_LIST_O_BEGIN);
+    TRY(st, emit_statement(reader, ctx, *dest, 0, 0));
+    *ctx.flags |= SERD_LIST_CONT;
+  } else {
+    *ctx.flags |= (end ? 0 : SERD_LIST_S_BEGIN);
+  }
+
+  if (end) {
+    return end_collection(reader, ctx, 0, 0, st);
+  }
+
+  /* The order of node allocation here is necessarily not in stack order,
+     so we create two nodes and recycle them throughout. */
+  Ref n1   = push_node_padded(reader, genid_size(reader), SERD_BLANK, "", 0);
+  Ref n2   = 0;
+  Ref node = n1;
+  Ref rest = 0;
+
+  ctx.subject = *dest;
+  while (!peek_delim(reader, ')')) {
+    // _:node rdf:first object
+    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);
+    }
+
+    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
+      } else {
+        set_blank_id(reader, rest, genid_size(reader));
+      }
+    }
+
+    // _:node rdf:rest _:rest
+    *ctx.flags |= SERD_LIST_CONT;
+    ctx.predicate = reader->rdf_rest;
+    TRY(st, emit_statement(reader, ctx, (end ? reader->rdf_nil : rest), 0, 0));
+
+    ctx.subject = rest;        // _:node = _:rest
+    rest        = node;        // _:rest = (old)_:node
+    node        = ctx.subject; // invariant
+  }
+
+  return end_collection(reader, ctx, n1, n2, st);
 }
 
 static SerdStatus
 read_subject(SerdReader* reader, ReadContext ctx, Ref* dest, int* s_type)
 {
-	SerdStatus st      = SERD_SUCCESS;
-	bool       ate_dot = false;
-	switch ((*s_type = peek_byte(reader))) {
-	case '[':
-		read_anon(reader, ctx, true, dest);
-		break;
-	case '(':
-		st = read_collection(reader, ctx, dest);
-		break;
-	case '_':
-		st = read_BLANK_NODE_LABEL(reader, dest, &ate_dot);
-		break;
-	default:
-		st = read_iri(reader, dest, &ate_dot);
-	}
-
-	if (ate_dot) {
-		pop_node(reader, *dest);
-		return r_err(reader, SERD_ERR_BAD_SYNTAX, "subject ends with `.'\n");
-	}
-
-	return st;
+  SerdStatus st      = SERD_SUCCESS;
+  bool       ate_dot = false;
+  switch ((*s_type = peek_byte(reader))) {
+  case '[':
+    read_anon(reader, ctx, true, dest);
+    break;
+  case '(':
+    st = read_collection(reader, ctx, dest);
+    break;
+  case '_':
+    st = read_BLANK_NODE_LABEL(reader, dest, &ate_dot);
+    break;
+  default:
+    st = read_iri(reader, dest, &ate_dot);
+  }
+
+  if (ate_dot) {
+    pop_node(reader, *dest);
+    return r_err(reader, SERD_ERR_BAD_SYNTAX, "subject ends with `.'\n");
+  }
+
+  return st;
 }
 
 static SerdStatus
 read_labelOrSubject(SerdReader* reader, Ref* dest)
 {
-	bool ate_dot = false;
-	switch (peek_byte(reader)) {
-	case '[':
-		eat_byte_safe(reader, '[');
-		read_ws_star(reader);
-		if (!eat_byte_check(reader, ']')) {
-			return SERD_ERR_BAD_SYNTAX;
-		}
-		*dest = blank_id(reader);
-		return SERD_SUCCESS;
-	case '_':
-		return read_BLANK_NODE_LABEL(reader, dest, &ate_dot);
-	default:
-		if (!read_iri(reader, dest, &ate_dot)) {
-			return SERD_SUCCESS;
-		} else {
-			return r_err(reader, SERD_ERR_BAD_SYNTAX,
-			             "expected label or subject\n");
-		}
-	}
+  bool ate_dot = false;
+  switch (peek_byte(reader)) {
+  case '[':
+    eat_byte_safe(reader, '[');
+    read_ws_star(reader);
+    if (!eat_byte_check(reader, ']')) {
+      return SERD_ERR_BAD_SYNTAX;
+    }
+    *dest = blank_id(reader);
+    return SERD_SUCCESS;
+  case '_':
+    return read_BLANK_NODE_LABEL(reader, dest, &ate_dot);
+  default:
+    if (!read_iri(reader, dest, &ate_dot)) {
+      return SERD_SUCCESS;
+    } else {
+      return r_err(reader, SERD_ERR_BAD_SYNTAX, "expected label or subject\n");
+    }
+  }
 }
 
 static SerdStatus
 read_triples(SerdReader* reader, ReadContext ctx, bool* ate_dot)
 {
-	SerdStatus st = SERD_FAILURE;
-	if (ctx.subject) {
-		read_ws_star(reader);
-		switch (peek_byte(reader)) {
-		case '.':
-			*ate_dot = eat_byte_safe(reader, '.');
-			return SERD_FAILURE;
-		case '}':
-			return SERD_FAILURE;
-		}
-		st = read_predicateObjectList(reader, ctx, ate_dot);
-	}
-	ctx.subject = ctx.predicate = 0;
-	return st > SERD_FAILURE ? st : SERD_SUCCESS;
+  SerdStatus st = SERD_FAILURE;
+  if (ctx.subject) {
+    read_ws_star(reader);
+    switch (peek_byte(reader)) {
+    case '.':
+      *ate_dot = eat_byte_safe(reader, '.');
+      return SERD_FAILURE;
+    case '}':
+      return SERD_FAILURE;
+    }
+    st = read_predicateObjectList(reader, ctx, ate_dot);
+  }
+
+  ctx.subject = ctx.predicate = 0;
+  return st > SERD_FAILURE ? st : SERD_SUCCESS;
 }
 
 static SerdStatus
 read_base(SerdReader* reader, bool sparql, bool token)
 {
-	SerdStatus st = SERD_SUCCESS;
-	if (token) {
-		TRY(st, eat_string(reader, "base", 4));
-	}
-
-	read_ws_star(reader);
-
-	Ref uri = 0;
-	TRY(st, read_IRIREF(reader, &uri));
-	if (reader->base_sink) {
-		TRY(st, reader->base_sink(reader->handle, deref(reader, uri)));
-	}
-	pop_node(reader, uri);
-
-	read_ws_star(reader);
-	if (!sparql) {
-		return eat_byte_check(reader, '.') ? SERD_SUCCESS : SERD_ERR_BAD_SYNTAX;
-	}
-
-	if (peek_byte(reader) == '.') {
-		return r_err(reader, SERD_ERR_BAD_SYNTAX,
-		             "full stop after SPARQL BASE\n");
-	}
-
-	return SERD_SUCCESS;
+  SerdStatus st = SERD_SUCCESS;
+  if (token) {
+    TRY(st, eat_string(reader, "base", 4));
+  }
+
+  read_ws_star(reader);
+
+  Ref uri = 0;
+  TRY(st, read_IRIREF(reader, &uri));
+  if (reader->base_sink) {
+    TRY(st, reader->base_sink(reader->handle, deref(reader, uri)));
+  }
+  pop_node(reader, uri);
+
+  read_ws_star(reader);
+  if (!sparql) {
+    return eat_byte_check(reader, '.') ? SERD_SUCCESS : SERD_ERR_BAD_SYNTAX;
+  }
+
+  if (peek_byte(reader) == '.') {
+    return r_err(reader, SERD_ERR_BAD_SYNTAX, "full stop after SPARQL BASE\n");
+  }
+
+  return SERD_SUCCESS;
 }
 
 static SerdStatus
 read_prefixID(SerdReader* reader, bool sparql, bool token)
 {
-	SerdStatus st = SERD_SUCCESS;
-	if (token) {
-		TRY(st, eat_string(reader, "prefix", 6));
-	}
-
-	read_ws_star(reader);
-	Ref  name = push_node(reader, SERD_LITERAL, "", 0);
-	if ((st = read_PN_PREFIX(reader, name)) > SERD_FAILURE) {
-		return st;
-	}
-
-	if (eat_byte_check(reader, ':') != ':') {
-		pop_node(reader, name);
-		return SERD_ERR_BAD_SYNTAX;
-	}
-
-	read_ws_star(reader);
-	Ref uri = 0;
-	TRY(st, read_IRIREF(reader, &uri));
-
-	if (reader->prefix_sink) {
-		st = reader->prefix_sink(reader->handle,
-		                         deref(reader, name),
-		                         deref(reader, 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;
-	}
-	return st;
+  SerdStatus st = SERD_SUCCESS;
+  if (token) {
+    TRY(st, eat_string(reader, "prefix", 6));
+  }
+
+  read_ws_star(reader);
+  Ref name = push_node(reader, SERD_LITERAL, "", 0);
+  if ((st = read_PN_PREFIX(reader, name)) > SERD_FAILURE) {
+    return st;
+  }
+
+  if (eat_byte_check(reader, ':') != ':') {
+    pop_node(reader, name);
+    return SERD_ERR_BAD_SYNTAX;
+  }
+
+  read_ws_star(reader);
+  Ref uri = 0;
+  TRY(st, read_IRIREF(reader, &uri));
+
+  if (reader->prefix_sink) {
+    st = reader->prefix_sink(
+      reader->handle, deref(reader, name), deref(reader, 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;
+  }
+
+  return st;
 }
 
 static SerdStatus
 read_directive(SerdReader* reader)
 {
-	const bool sparql = peek_byte(reader) != '@';
-	if (!sparql) {
-		eat_byte_safe(reader, '@');
-		switch (peek_byte(reader)) {
-		case 'B': case 'P':
-			return r_err(reader, SERD_ERR_BAD_SYNTAX, "uppercase directive\n");
-		}
-	}
-
-	switch (peek_byte(reader)) {
-	case 'B': case 'b': return read_base(reader, sparql, true);
-	case 'P': case 'p': return read_prefixID(reader, sparql, true);
-	default: break;
-	}
-
-	return r_err(reader, SERD_ERR_BAD_SYNTAX, "invalid directive\n");
+  const bool sparql = peek_byte(reader) != '@';
+  if (!sparql) {
+    eat_byte_safe(reader, '@');
+    switch (peek_byte(reader)) {
+    case 'B':
+    case 'P':
+      return r_err(reader, SERD_ERR_BAD_SYNTAX, "uppercase directive\n");
+    }
+  }
+
+  switch (peek_byte(reader)) {
+  case 'B':
+  case 'b':
+    return read_base(reader, sparql, true);
+  case 'P':
+  case 'p':
+    return read_prefixID(reader, sparql, true);
+  default:
+    break;
+  }
+
+  return r_err(reader, SERD_ERR_BAD_SYNTAX, "invalid directive\n");
 }
 
 static SerdStatus
 read_wrappedGraph(SerdReader* reader, ReadContext* ctx)
 {
-	if (!eat_byte_check(reader, '{')) {
-		return SERD_ERR_BAD_SYNTAX;
-	}
-
-	read_ws_star(reader);
-	while (peek_byte(reader) != '}') {
-		bool ate_dot = false;
-		int  s_type  = 0;
-		ctx->subject = 0;
-		SerdStatus st = read_subject(reader, *ctx, &ctx->subject, &s_type);
-		if (st) {
-			return r_err(reader, SERD_ERR_BAD_SYNTAX, "bad subject\n");
-		}
-
-		if (read_triples(reader, *ctx, &ate_dot) && s_type != '[') {
-			return r_err(reader, SERD_ERR_BAD_SYNTAX,
-			             "missing predicate object list\n");
-		}
-
-		pop_node(reader, ctx->subject);
-		read_ws_star(reader);
-		if (peek_byte(reader) == '.') {
-			eat_byte_safe(reader, '.');
-		}
-		read_ws_star(reader);
-	}
-
-	eat_byte_safe(reader, '}');
-	read_ws_star(reader);
-	if (peek_byte(reader) == '.') {
-		return r_err(reader, SERD_ERR_BAD_SYNTAX,
-		             "graph followed by `.'\n");
-	}
-
-	return SERD_SUCCESS;
+  if (!eat_byte_check(reader, '{')) {
+    return SERD_ERR_BAD_SYNTAX;
+  }
+
+  read_ws_star(reader);
+  while (peek_byte(reader) != '}') {
+    bool ate_dot  = false;
+    int  s_type   = 0;
+    ctx->subject  = 0;
+    SerdStatus st = read_subject(reader, *ctx, &ctx->subject, &s_type);
+    if (st) {
+      return r_err(reader, SERD_ERR_BAD_SYNTAX, "bad subject\n");
+    }
+
+    if (read_triples(reader, *ctx, &ate_dot) && s_type != '[') {
+      return r_err(
+        reader, SERD_ERR_BAD_SYNTAX, "missing predicate object list\n");
+    }
+
+    pop_node(reader, ctx->subject);
+    read_ws_star(reader);
+    if (peek_byte(reader) == '.') {
+      eat_byte_safe(reader, '.');
+    }
+    read_ws_star(reader);
+  }
+
+  eat_byte_safe(reader, '}');
+  read_ws_star(reader);
+  if (peek_byte(reader) == '.') {
+    return r_err(reader, SERD_ERR_BAD_SYNTAX, "graph followed by `.'\n");
+  }
+
+  return SERD_SUCCESS;
 }
 
 static int
 tokcmp(SerdReader* reader, Ref ref, const char* tok, size_t n)
 {
-	SerdNode* node = deref(reader, ref);
-	if (!node || node->n_bytes != n) {
-		return -1;
-	}
-	return serd_strncasecmp((const char*)node->buf, tok, n);
+  SerdNode* node = deref(reader, ref);
+  if (!node || node->n_bytes != n) {
+    return -1;
+  }
+
+  return serd_strncasecmp((const char*)node->buf, tok, n);
 }
 
 SerdStatus
 read_n3_statement(SerdReader* reader)
 {
-	SerdStatementFlags flags   = 0;
-	ReadContext        ctx     = { 0, 0, 0, 0, 0, 0, &flags };
-	bool               ate_dot = false;
-	int                s_type  = 0;
-	SerdStatus         st      = SERD_SUCCESS;
-	read_ws_star(reader);
-	switch (peek_byte(reader)) {
-	case '\0':
-		eat_byte_safe(reader, '\0');
-		return SERD_FAILURE;
-	case EOF:
-		return SERD_FAILURE;
-	case '@':
-		if (!fancy_syntax(reader)) {
-			return r_err(reader, SERD_ERR_BAD_SYNTAX,
-			             "syntax does not support directives\n");
-		}
-		TRY(st, read_directive(reader));
-		read_ws_star(reader);
-		break;
-	case '{':
-		if (reader->syntax == SERD_TRIG) {
-			TRY(st, read_wrappedGraph(reader, &ctx));
-			read_ws_star(reader);
-		} else {
-			return r_err(reader, SERD_ERR_BAD_SYNTAX,
-			             "syntax does not support graphs\n");
-		}
-		break;
-	default:
-		if ((st = read_subject(reader, ctx, &ctx.subject, &s_type)) >
-		    SERD_FAILURE) {
-			return st;
-		}
-
-		if (!tokcmp(reader, ctx.subject, "base", 4)) {
-			st = read_base(reader, true, false);
-		} else if (!tokcmp(reader, ctx.subject, "prefix", 6)) {
-			st = read_prefixID(reader, true, false);
-		} else if (!tokcmp(reader, ctx.subject, "graph", 5)) {
-			read_ws_star(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) == '{') {
-			if (s_type == '(' || (s_type == '[' && !*ctx.flags)) {
-				return r_err(reader, SERD_ERR_BAD_SYNTAX,
-				             "invalid graph name\n");
-			}
-			ctx.graph   = ctx.subject;
-			ctx.subject = 0;
-			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 == '[') {
-				return SERD_SUCCESS;
-			}
-
-			if (ate_dot) {
-				return r_err(reader, SERD_ERR_BAD_SYNTAX,
-				             "unexpected end of statement\n");
-			}
-
-			return st > SERD_FAILURE ? st : SERD_ERR_BAD_SYNTAX;
-		} else if (!ate_dot) {
-			read_ws_star(reader);
-			st = (eat_byte_check(reader, '.') == '.') ? SERD_SUCCESS
-			                                          : SERD_ERR_BAD_SYNTAX;
-		}
-		break;
-	}
-	return st;
+  SerdStatementFlags flags   = 0;
+  ReadContext        ctx     = {0, 0, 0, 0, 0, 0, &flags};
+  bool               ate_dot = false;
+  int                s_type  = 0;
+  SerdStatus         st      = SERD_SUCCESS;
+  read_ws_star(reader);
+  switch (peek_byte(reader)) {
+  case '\0':
+    eat_byte_safe(reader, '\0');
+    return SERD_FAILURE;
+  case EOF:
+    return SERD_FAILURE;
+  case '@':
+    if (!fancy_syntax(reader)) {
+      return r_err(
+        reader, SERD_ERR_BAD_SYNTAX, "syntax does not support directives\n");
+    }
+    TRY(st, read_directive(reader));
+    read_ws_star(reader);
+    break;
+  case '{':
+    if (reader->syntax == SERD_TRIG) {
+      TRY(st, read_wrappedGraph(reader, &ctx));
+      read_ws_star(reader);
+    } else {
+      return r_err(
+        reader, SERD_ERR_BAD_SYNTAX, "syntax does not support graphs\n");
+    }
+    break;
+  default:
+    if ((st = read_subject(reader, ctx, &ctx.subject, &s_type)) >
+        SERD_FAILURE) {
+      return st;
+    }
+
+    if (!tokcmp(reader, ctx.subject, "base", 4)) {
+      st = read_base(reader, true, false);
+    } else if (!tokcmp(reader, ctx.subject, "prefix", 6)) {
+      st = read_prefixID(reader, true, false);
+    } else if (!tokcmp(reader, ctx.subject, "graph", 5)) {
+      read_ws_star(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) == '{') {
+      if (s_type == '(' || (s_type == '[' && !*ctx.flags)) {
+        return r_err(reader, SERD_ERR_BAD_SYNTAX, "invalid graph name\n");
+      }
+      ctx.graph   = ctx.subject;
+      ctx.subject = 0;
+      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 == '[') {
+        return SERD_SUCCESS;
+      }
+
+      if (ate_dot) {
+        return r_err(
+          reader, SERD_ERR_BAD_SYNTAX, "unexpected end of statement\n");
+      }
+
+      return st > SERD_FAILURE ? st : SERD_ERR_BAD_SYNTAX;
+    } else if (!ate_dot) {
+      read_ws_star(reader);
+      st = (eat_byte_check(reader, '.') == '.') ? SERD_SUCCESS
+                                                : SERD_ERR_BAD_SYNTAX;
+    }
+    break;
+  }
+  return st;
 }
 
 static void
 skip_until(SerdReader* reader, uint8_t byte)
 {
-	for (int c = 0; (c = peek_byte(reader)) && c != byte;) {
-		eat_byte_safe(reader, c);
-	}
+  for (int c = 0; (c = peek_byte(reader)) && c != byte;) {
+    eat_byte_safe(reader, c);
+  }
 }
 
 SerdStatus
 read_turtleTrigDoc(SerdReader* reader)
 {
-	while (!reader->source.eof) {
-		const SerdStatus st = read_n3_statement(reader);
-		if (st > SERD_FAILURE) {
-			if (reader->strict) {
-				return st;
-			}
-			skip_until(reader, '\n');
-		}
-	}
-	return SERD_SUCCESS;
+  while (!reader->source.eof) {
+    const SerdStatus st = read_n3_statement(reader);
+    if (st > SERD_FAILURE) {
+      if (reader->strict) {
+        return st;
+      }
+      skip_until(reader, '\n');
+    }
+  }
+
+  return SERD_SUCCESS;
 }
 
 SerdStatus
 read_nquadsDoc(SerdReader* reader)
 {
-	SerdStatus st = SERD_SUCCESS;
-	while (!reader->source.eof) {
-		SerdStatementFlags flags   = 0;
-		ReadContext        ctx     = { 0, 0, 0, 0, 0, 0, &flags };
-		bool               ate_dot = false;
-		int                s_type  = 0;
-		read_ws_star(reader);
-		if (peek_byte(reader) == EOF) {
-			break;
-		}
-
-		if (peek_byte(reader) == '@') {
-			return r_err(reader, SERD_ERR_BAD_SYNTAX,
-			             "syntax does not support directives\n");
-		}
-
-		// subject predicate object
-		if ((st = read_subject(reader, ctx, &ctx.subject, &s_type)) ||
-		    !read_ws_star(reader) ||
-		    (st = read_IRIREF(reader, &ctx.predicate)) ||
-		    !read_ws_star(reader) ||
-		    (st = read_object(reader, &ctx, false, &ate_dot))) {
-			return st;
-		}
-
-		if (!ate_dot) {  // graphLabel?
-			read_ws_star(reader);
-			switch (peek_byte(reader)) {
-			case '.':
-				break;
-			case '_':
-				TRY(st, read_BLANK_NODE_LABEL(reader, &ctx.graph, &ate_dot));
-				break;
-			default:
-				TRY(st, read_IRIREF(reader, &ctx.graph));
-			}
-
-			// Terminating '.'
-			read_ws_star(reader);
-			if (!eat_byte_check(reader, '.')) {
-				return SERD_ERR_BAD_SYNTAX;
-			}
-		}
-
-		TRY(st, emit_statement(reader, ctx, ctx.object, ctx.datatype, ctx.lang));
-
-		pop_node(reader, ctx.graph);
-		pop_node(reader, ctx.lang);
-		pop_node(reader, ctx.datatype);
-		pop_node(reader, ctx.object);
-	}
-	return SERD_SUCCESS;
+  SerdStatus st = SERD_SUCCESS;
+  while (!reader->source.eof) {
+    SerdStatementFlags flags   = 0;
+    ReadContext        ctx     = {0, 0, 0, 0, 0, 0, &flags};
+    bool               ate_dot = false;
+    int                s_type  = 0;
+    read_ws_star(reader);
+    if (peek_byte(reader) == EOF) {
+      break;
+    }
+
+    if (peek_byte(reader) == '@') {
+      return r_err(
+        reader, SERD_ERR_BAD_SYNTAX, "syntax does not support directives\n");
+    }
+
+    // subject predicate object
+    if ((st = read_subject(reader, ctx, &ctx.subject, &s_type)) ||
+        !read_ws_star(reader) || (st = read_IRIREF(reader, &ctx.predicate)) ||
+        !read_ws_star(reader) ||
+        (st = read_object(reader, &ctx, false, &ate_dot))) {
+      return st;
+    }
+
+    if (!ate_dot) { // graphLabel?
+      read_ws_star(reader);
+      switch (peek_byte(reader)) {
+      case '.':
+        break;
+      case '_':
+        TRY(st, read_BLANK_NODE_LABEL(reader, &ctx.graph, &ate_dot));
+        break;
+      default:
+        TRY(st, read_IRIREF(reader, &ctx.graph));
+      }
+
+      // Terminating '.'
+      read_ws_star(reader);
+      if (!eat_byte_check(reader, '.')) {
+        return SERD_ERR_BAD_SYNTAX;
+      }
+    }
+
+    TRY(st, emit_statement(reader, ctx, ctx.object, ctx.datatype, ctx.lang));
+
+    pop_node(reader, ctx.graph);
+    pop_node(reader, ctx.lang);
+    pop_node(reader, ctx.datatype);
+    pop_node(reader, ctx.object);
+  }
+  return SERD_SUCCESS;
 }
diff --git a/src/node.c b/src/node.c
index ab153b2b..6169895d 100644
--- a/src/node.c
+++ b/src/node.c
@@ -31,93 +31,93 @@
 #include <string.h>
 
 #ifdef _WIN32
-#    ifndef isnan
-#        define isnan(x) _isnan(x)
-#    endif
-#    ifndef isinf
-#        define isinf(x) (!_finite(x))
-#    endif
+#  ifndef isnan
+#    define isnan(x) _isnan(x)
+#  endif
+#  ifndef isinf
+#    define isinf(x) (!_finite(x))
+#  endif
 #endif
 
 SerdNode
 serd_node_from_string(SerdType type, const uint8_t* str)
 {
-	if (!str) {
-		return SERD_NODE_NULL;
-	}
-
-	SerdNodeFlags flags       = 0;
-	size_t        buf_n_bytes = 0;
-	const size_t  buf_n_chars = serd_strlen(str, &buf_n_bytes, &flags);
-	SerdNode ret = {str, buf_n_bytes, buf_n_chars, flags, type};
-	return ret;
+  if (!str) {
+    return SERD_NODE_NULL;
+  }
+
+  SerdNodeFlags flags       = 0;
+  size_t        buf_n_bytes = 0;
+  const size_t  buf_n_chars = serd_strlen(str, &buf_n_bytes, &flags);
+  SerdNode      ret         = {str, buf_n_bytes, buf_n_chars, flags, type};
+  return ret;
 }
 
 SerdNode
 serd_node_from_substring(SerdType type, const uint8_t* str, const size_t len)
 {
-	if (!str) {
-		return SERD_NODE_NULL;
-	}
-
-	SerdNodeFlags flags       = 0;
-	size_t        buf_n_bytes = 0;
-	const size_t  buf_n_chars = serd_substrlen(str, len, &buf_n_bytes, &flags);
-	assert(buf_n_bytes <= len);
-	SerdNode ret = { str, buf_n_bytes, buf_n_chars, flags, type };
-	return ret;
+  if (!str) {
+    return SERD_NODE_NULL;
+  }
+
+  SerdNodeFlags flags       = 0;
+  size_t        buf_n_bytes = 0;
+  const size_t  buf_n_chars = serd_substrlen(str, len, &buf_n_bytes, &flags);
+  assert(buf_n_bytes <= len);
+  SerdNode ret = {str, buf_n_bytes, buf_n_chars, flags, type};
+  return ret;
 }
 
 SerdNode
 serd_node_copy(const SerdNode* node)
 {
-	if (!node || !node->buf) {
-		return SERD_NODE_NULL;
-	}
-
-	SerdNode copy = *node;
-	uint8_t* buf  = (uint8_t*)malloc(copy.n_bytes + 1);
-	memcpy(buf, node->buf, copy.n_bytes + 1);
-	copy.buf = buf;
-	return copy;
+  if (!node || !node->buf) {
+    return SERD_NODE_NULL;
+  }
+
+  SerdNode copy = *node;
+  uint8_t* buf  = (uint8_t*)malloc(copy.n_bytes + 1);
+  memcpy(buf, node->buf, copy.n_bytes + 1);
+  copy.buf = buf;
+  return copy;
 }
 
 bool
 serd_node_equals(const SerdNode* a, const SerdNode* b)
 {
-	return (a == b)
-		|| (a->type == b->type
-		    && a->n_bytes == b->n_bytes
-		    && a->n_chars == b->n_chars
-		    && ((a->buf == b->buf) || !memcmp((const char*)a->buf,
-		                                      (const char*)b->buf,
-		                                      a->n_bytes + 1)));
+  return (a == b) ||
+         (a->type == b->type && a->n_bytes == b->n_bytes &&
+          a->n_chars == b->n_chars &&
+          ((a->buf == b->buf) ||
+           !memcmp((const char*)a->buf, (const char*)b->buf, a->n_bytes + 1)));
 }
 
 static size_t
 serd_uri_string_length(const SerdURI* uri)
 {
-	size_t len = uri->path_base.len;
+  size_t len = uri->path_base.len;
 
-#define ADD_LEN(field, n_delims) \
-	if ((field).len) { len += (field).len + (n_delims); }
+#define ADD_LEN(field, n_delims)     \
+  if ((field).len) {                 \
+    len += (field).len + (n_delims); \
+  }
 
-	ADD_LEN(uri->path,      1)  // + possible leading `/'
-	ADD_LEN(uri->scheme,    1)  // + trailing `:'
-	ADD_LEN(uri->authority, 2)  // + leading `//'
-	ADD_LEN(uri->query,     1)  // + leading `?'
-	ADD_LEN(uri->fragment,  1)  // + leading `#'
+  ADD_LEN(uri->path, 1)      // + possible leading `/'
+  ADD_LEN(uri->scheme, 1)    // + trailing `:'
+  ADD_LEN(uri->authority, 2) // + leading `//'
+  ADD_LEN(uri->query, 1)     // + leading `?'
+  ADD_LEN(uri->fragment, 1)  // + leading `#'
 
-	return len + 2;  // + 2 for authority `//'
+  return len + 2; // + 2 for authority `//'
 }
 
 static size_t
 string_sink(const void* buf, size_t len, void* stream)
 {
-	uint8_t** ptr = (uint8_t**)stream;
-	memcpy(*ptr, buf, len);
-	*ptr += len;
-	return len;
+  uint8_t** ptr = (uint8_t**)stream;
+  memcpy(*ptr, buf, len);
+  *ptr += len;
+  return len;
 }
 
 SerdNode
@@ -125,9 +125,9 @@ serd_node_new_uri_from_node(const SerdNode* uri_node,
                             const SerdURI*  base,
                             SerdURI*        out)
 {
-	return (uri_node->type == SERD_URI && uri_node->buf)
-		? serd_node_new_uri_from_string(uri_node->buf, base, out)
-		: SERD_NODE_NULL;
+  return (uri_node->type == SERD_URI && uri_node->buf)
+           ? serd_node_new_uri_from_string(uri_node->buf, base, out)
+           : SERD_NODE_NULL;
 }
 
 SerdNode
@@ -135,33 +135,50 @@ serd_node_new_uri_from_string(const uint8_t* str,
                               const SerdURI* base,
                               SerdURI*       out)
 {
-	if (!str || str[0] == '\0') {
-		// Empty URI => Base URI, or nothing if no base is given
-		return base ? serd_node_new_uri(base, NULL, out) : SERD_NODE_NULL;
-	}
-
-	SerdURI uri;
-	serd_uri_parse(str, &uri);
-	return serd_node_new_uri(&uri, base, out);  // Resolve/Serialise
+  if (!str || str[0] == '\0') {
+    // Empty URI => Base URI, or nothing if no base is given
+    return base ? serd_node_new_uri(base, NULL, out) : SERD_NODE_NULL;
+  }
+
+  SerdURI uri;
+  serd_uri_parse(str, &uri);
+  return serd_node_new_uri(&uri, base, out); // Resolve/Serialise
 }
 
 static inline bool
 is_uri_path_char(const uint8_t c)
 {
-	if (is_alpha(c) || is_digit(c)) {
-		return true;
-	}
-	switch (c) {
-	case '-': case '.': case '_': case '~':	 // unreserved
-	case ':': case '@':	 // pchar
-	case '/':  // separator
-	// sub-delims
-	case '!': case '$': case '&': case '\'': case '(': case ')':
-	case '*': case '+': case ',': case ';': case '=':
-		return true;
-	default:
-		return false;
-	}
+  if (is_alpha(c) || is_digit(c)) {
+    return true;
+  }
+
+  switch (c) {
+  // unreserved:
+  case '-':
+  case '.':
+  case '_':
+  case '~':
+  // pchar:
+  case ':':
+  case '@':
+  // separator:
+  case '/':
+  // sub-delimeters:
+  case '!':
+  case '$':
+  case '&':
+  case '\'':
+  case '(':
+  case ')':
+  case '*':
+  case '+':
+  case ',':
+  case ';':
+  case '=':
+    return true;
+  default:
+    return false;
+  }
 }
 
 SerdNode
@@ -170,69 +187,69 @@ serd_node_new_file_uri(const uint8_t* path,
                        SerdURI*       out,
                        bool           escape)
 {
-	const size_t path_len     = strlen((const char*)path);
-	const size_t hostname_len = hostname ? strlen((const char*)hostname) : 0;
-	const bool   evil         = is_windows_path(path);
-	size_t       uri_len      = 0;
-	uint8_t*     uri          = NULL;
-
-	if (path[0] == '/' || is_windows_path(path)) {
-		uri_len = strlen("file://") + hostname_len + evil;
-		uri = (uint8_t*)malloc(uri_len + 1);
-		snprintf((char*)uri, uri_len + 1, "file://%s%s",
-		         hostname ? (const char*)hostname : "",
-		         evil ? "/" : "");
-	}
-
-	SerdChunk chunk = { uri, uri_len };
-	for (size_t i = 0; i < path_len; ++i) {
-		if (evil && path[i] == '\\') {
-			serd_chunk_sink("/", 1, &chunk);
-		} else if (path[i] == '%') {
-			serd_chunk_sink("%%", 2, &chunk);
-		} else if (!escape || is_uri_path_char(path[i])) {
-			serd_chunk_sink(path + i, 1, &chunk);
-		} else {
-			char escape_str[4] = { '%', 0, 0, 0 };
-			snprintf(escape_str + 1,
-			         sizeof(escape_str) - 1,
-			         "%X",
-			         (unsigned)path[i]);
-			serd_chunk_sink(escape_str, 3, &chunk);
-		}
-	}
-	serd_chunk_sink_finish(&chunk);
-
-	if (out) {
-		serd_uri_parse(chunk.buf, out);
-	}
-
-	return serd_node_from_substring(SERD_URI, chunk.buf, chunk.len);
+  const size_t path_len     = strlen((const char*)path);
+  const size_t hostname_len = hostname ? strlen((const char*)hostname) : 0;
+  const bool   evil         = is_windows_path(path);
+  size_t       uri_len      = 0;
+  uint8_t*     uri          = NULL;
+
+  if (path[0] == '/' || is_windows_path(path)) {
+    uri_len = strlen("file://") + hostname_len + evil;
+    uri     = (uint8_t*)malloc(uri_len + 1);
+    snprintf((char*)uri,
+             uri_len + 1,
+             "file://%s%s",
+             hostname ? (const char*)hostname : "",
+             evil ? "/" : "");
+  }
+
+  SerdChunk chunk = {uri, uri_len};
+  for (size_t i = 0; i < path_len; ++i) {
+    if (evil && path[i] == '\\') {
+      serd_chunk_sink("/", 1, &chunk);
+    } else if (path[i] == '%') {
+      serd_chunk_sink("%%", 2, &chunk);
+    } else if (!escape || is_uri_path_char(path[i])) {
+      serd_chunk_sink(path + i, 1, &chunk);
+    } else {
+      char escape_str[4] = {'%', 0, 0, 0};
+      snprintf(escape_str + 1, sizeof(escape_str) - 1, "%X", (unsigned)path[i]);
+      serd_chunk_sink(escape_str, 3, &chunk);
+    }
+  }
+
+  serd_chunk_sink_finish(&chunk);
+
+  if (out) {
+    serd_uri_parse(chunk.buf, out);
+  }
+
+  return serd_node_from_substring(SERD_URI, chunk.buf, chunk.len);
 }
 
 SerdNode
 serd_node_new_uri(const SerdURI* uri, const SerdURI* base, SerdURI* out)
 {
-	SerdURI abs_uri = *uri;
-	if (base) {
-		serd_uri_resolve(uri, base, &abs_uri);
-	}
-
-	const size_t len        = serd_uri_string_length(&abs_uri);
-	uint8_t*     buf        = (uint8_t*)malloc(len + 1);
-	SerdNode     node       = { buf, 0, 0, 0, SERD_URI };
-	uint8_t*     ptr        = buf;
-	const size_t actual_len = serd_uri_serialise(&abs_uri, string_sink, &ptr);
-
-	buf[actual_len] = '\0';
-	node.n_bytes    = actual_len;
-	node.n_chars    = serd_strlen(buf, NULL, NULL);
-
-	if (out) {
-		serd_uri_parse(buf, out);  // TODO: cleverly avoid double parse
-	}
-
-	return node;
+  SerdURI abs_uri = *uri;
+  if (base) {
+    serd_uri_resolve(uri, base, &abs_uri);
+  }
+
+  const size_t len        = serd_uri_string_length(&abs_uri);
+  uint8_t*     buf        = (uint8_t*)malloc(len + 1);
+  SerdNode     node       = {buf, 0, 0, 0, SERD_URI};
+  uint8_t*     ptr        = buf;
+  const size_t actual_len = serd_uri_serialise(&abs_uri, string_sink, &ptr);
+
+  buf[actual_len] = '\0';
+  node.n_bytes    = actual_len;
+  node.n_chars    = serd_strlen(buf, NULL, NULL);
+
+  if (out) {
+    serd_uri_parse(buf, out); // TODO: cleverly avoid double parse
+  }
+
+  return node;
 }
 
 SerdNode
@@ -241,129 +258,131 @@ serd_node_new_relative_uri(const SerdURI* uri,
                            const SerdURI* root,
                            SerdURI*       out)
 {
-	const size_t uri_len  = serd_uri_string_length(uri);
-	const size_t base_len = serd_uri_string_length(base);
-	uint8_t*     buf        = (uint8_t*)malloc(uri_len + base_len + 1);
-	SerdNode     node       = { buf, 0, 0, 0, SERD_URI };
-	uint8_t*     ptr        = buf;
-	const size_t actual_len = serd_uri_serialise_relative(
-		uri, base, root, string_sink, &ptr);
-
-	buf[actual_len] = '\0';
-	node.n_bytes    = actual_len;
-	node.n_chars    = serd_strlen(buf, NULL, NULL);
-
-	if (out) {
-		serd_uri_parse(buf, out);  // TODO: cleverly avoid double parse
-	}
-
-	return node;
+  const size_t uri_len  = serd_uri_string_length(uri);
+  const size_t base_len = serd_uri_string_length(base);
+  uint8_t*     buf      = (uint8_t*)malloc(uri_len + base_len + 1);
+  SerdNode     node     = {buf, 0, 0, 0, SERD_URI};
+  uint8_t*     ptr      = buf;
+  const size_t actual_len =
+    serd_uri_serialise_relative(uri, base, root, string_sink, &ptr);
+
+  buf[actual_len] = '\0';
+  node.n_bytes    = actual_len;
+  node.n_chars    = serd_strlen(buf, NULL, NULL);
+
+  if (out) {
+    serd_uri_parse(buf, out); // TODO: cleverly avoid double parse
+  }
+
+  return node;
 }
 
 static inline unsigned
 serd_digits(double abs)
 {
-	const double lg = ceil(log10(floor(abs) + 1.0));
-	return lg < 1.0 ? 1U : (unsigned)lg;
+  const double lg = ceil(log10(floor(abs) + 1.0));
+  return lg < 1.0 ? 1U : (unsigned)lg;
 }
 
 SerdNode
 serd_node_new_decimal(double d, unsigned frac_digits)
 {
-	if (isnan(d) || isinf(d)) {
-		return SERD_NODE_NULL;
-	}
-
-	const double   abs_d      = fabs(d);
-	const unsigned int_digits = serd_digits(abs_d);
-	char*          buf        = (char*)calloc(int_digits + frac_digits + 3, 1);
-	SerdNode       node       = { (const uint8_t*)buf, 0, 0, 0, SERD_LITERAL };
-	const double   int_part   = floor(abs_d);
-
-	// Point s to decimal point location
-	char* s = buf + int_digits;
-	if (d < 0.0) {
-		*buf = '-';
-		++s;
-	}
-
-	// Write integer part (right to left)
-	char*    t   = s - 1;
-	uint64_t dec = (uint64_t)int_part;
-	do {
-		*t-- = (char)('0' + dec % 10);
-	} while ((dec /= 10) > 0);
-
-	*s++ = '.';
-
-	// Write fractional part (right to left)
-	double frac_part = fabs(d - int_part);
-	if (frac_part < DBL_EPSILON) {
-		*s++ = '0';
-		node.n_bytes = node.n_chars = (size_t)(s - buf);
-	} else {
-		uint64_t frac = (uint64_t)llround(frac_part * pow(10.0, (int)frac_digits));
-		s += frac_digits - 1;
-		unsigned i = 0;
-
-		// Skip trailing zeros
-		for (; i < frac_digits - 1 && !(frac % 10); ++i, --s, frac /= 10) {}
-
-		node.n_bytes = node.n_chars = (size_t)(s - buf) + 1u;
-
-		// Write digits from last trailing zero to decimal point
-		for (; i < frac_digits; ++i) {
-			*s-- = (char)('0' + (frac % 10));
-			frac /= 10;
-		}
-	}
-
-	return node;
+  if (isnan(d) || isinf(d)) {
+    return SERD_NODE_NULL;
+  }
+
+  const double   abs_d      = fabs(d);
+  const unsigned int_digits = serd_digits(abs_d);
+  char*          buf        = (char*)calloc(int_digits + frac_digits + 3, 1);
+  SerdNode       node       = {(const uint8_t*)buf, 0, 0, 0, SERD_LITERAL};
+  const double   int_part   = floor(abs_d);
+
+  // Point s to decimal point location
+  char* s = buf + int_digits;
+  if (d < 0.0) {
+    *buf = '-';
+    ++s;
+  }
+
+  // Write integer part (right to left)
+  char*    t   = s - 1;
+  uint64_t dec = (uint64_t)int_part;
+  do {
+    *t-- = (char)('0' + dec % 10);
+  } while ((dec /= 10) > 0);
+
+  *s++ = '.';
+
+  // Write fractional part (right to left)
+  double frac_part = fabs(d - int_part);
+  if (frac_part < DBL_EPSILON) {
+    *s++         = '0';
+    node.n_bytes = node.n_chars = (size_t)(s - buf);
+  } else {
+    uint64_t frac = (uint64_t)llround(frac_part * pow(10.0, (int)frac_digits));
+    s += frac_digits - 1;
+    unsigned i = 0;
+
+    // Skip trailing zeros
+    for (; i < frac_digits - 1 && !(frac % 10); ++i, --s, frac /= 10) {
+    }
+
+    node.n_bytes = node.n_chars = (size_t)(s - buf) + 1u;
+
+    // Write digits from last trailing zero to decimal point
+    for (; i < frac_digits; ++i) {
+      *s-- = (char)('0' + (frac % 10));
+      frac /= 10;
+    }
+  }
+
+  return node;
 }
 
 SerdNode
 serd_node_new_integer(int64_t i)
 {
-	int64_t        abs_i  = (i < 0) ? -i : i;
-	const unsigned digits = serd_digits((double)abs_i);
-	char*          buf    = (char*)calloc(digits + 2, 1);
-	SerdNode       node   = { (const uint8_t*)buf, 0, 0, 0, SERD_LITERAL };
-
-	// Point s to the end
-	char* s = buf + digits - 1;
-	if (i < 0) {
-		*buf = '-';
-		++s;
-	}
-
-	node.n_bytes = node.n_chars = (size_t)(s - buf) + 1u;
-
-	// Write integer part (right to left)
-	do {
-		*s-- = (char)('0' + (abs_i % 10));
-	} while ((abs_i /= 10) > 0);
-
-	return node;
+  int64_t        abs_i  = (i < 0) ? -i : i;
+  const unsigned digits = serd_digits((double)abs_i);
+  char*          buf    = (char*)calloc(digits + 2, 1);
+  SerdNode       node   = {(const uint8_t*)buf, 0, 0, 0, SERD_LITERAL};
+
+  // Point s to the end
+  char* s = buf + digits - 1;
+  if (i < 0) {
+    *buf = '-';
+    ++s;
+  }
+
+  node.n_bytes = node.n_chars = (size_t)(s - buf) + 1u;
+
+  // Write integer part (right to left)
+  do {
+    *s-- = (char)('0' + (abs_i % 10));
+  } while ((abs_i /= 10) > 0);
+
+  return node;
 }
 
 SerdNode
 serd_node_new_blob(const void* buf, size_t size, bool wrap_lines)
 {
-	const size_t len  = serd_base64_get_length(size, wrap_lines);
-	uint8_t*     str  = (uint8_t*)calloc(len + 2, 1);
-	SerdNode     node = { str, len, len, 0, SERD_LITERAL };
-
-	if (serd_base64_encode(str, buf, size, wrap_lines)) {
-		node.flags |= SERD_HAS_NEWLINE;
-	}
-	return node;
+  const size_t len  = serd_base64_get_length(size, wrap_lines);
+  uint8_t*     str  = (uint8_t*)calloc(len + 2, 1);
+  SerdNode     node = {str, len, len, 0, SERD_LITERAL};
+
+  if (serd_base64_encode(str, buf, size, wrap_lines)) {
+    node.flags |= SERD_HAS_NEWLINE;
+  }
+
+  return node;
 }
 
 void
 serd_node_free(SerdNode* node)
 {
-	if (node && node->buf) {
-		free((uint8_t*)node->buf);
-		node->buf = NULL;
-	}
+  if (node && node->buf) {
+    free((uint8_t*)node->buf);
+    node->buf = NULL;
+  }
 }
diff --git a/src/node.h b/src/node.h
index f99da1a6..e380f038 100644
--- a/src/node.h
+++ b/src/node.h
@@ -22,24 +22,27 @@
 #include <stddef.h>
 
 struct SerdNodeImpl {
-	size_t        n_bytes;  /**< Size in bytes (not including null) */
-	SerdNodeFlags flags;    /**< Node flags (e.g. string properties) */
-	SerdType      type;     /**< Node type */
+  size_t        n_bytes; /**< Size in bytes (not including null) */
+  SerdNodeFlags flags;   /**< Node flags (e.g. string properties) */
+  SerdType      type;    /**< Node type */
 };
 
 static inline char*
 serd_node_buffer(SerdNode* node)
 {
-	return (char*)(node + 1);
+  return (char*)(node + 1);
 }
 
 static inline const char*
 serd_node_buffer_c(const SerdNode* node)
 {
-	return (const char*)(node + 1);
+  return (const char*)(node + 1);
 }
 
-SerdNode* serd_node_malloc(size_t n_bytes, SerdNodeFlags flags, SerdType type);
-void      serd_node_set(SerdNode** dst, const SerdNode* src);
+SerdNode*
+serd_node_malloc(size_t n_bytes, SerdNodeFlags flags, SerdType type);
 
-#endif  // SERD_NODE_H
+void
+serd_node_set(SerdNode** dst, const SerdNode* src);
+
+#endif // SERD_NODE_H
diff --git a/src/reader.c b/src/reader.c
index 2b802b5f..d0e0fbe2 100644
--- a/src/reader.c
+++ b/src/reader.c
@@ -29,181 +29,183 @@
 SerdStatus
 r_err(SerdReader* reader, SerdStatus st, const char* fmt, ...)
 {
-	va_list args;
-	va_start(args, fmt);
-	const Cursor* const cur = &reader->source.cur;
-	const SerdError e = { st, cur->filename, cur->line, cur->col, fmt, &args };
-	serd_error(reader->error_sink, reader->error_handle, &e);
-	va_end(args);
-	return st;
+  va_list args;
+  va_start(args, fmt);
+  const Cursor* const cur = &reader->source.cur;
+  const SerdError     e = {st, cur->filename, cur->line, cur->col, fmt, &args};
+  serd_error(reader->error_sink, reader->error_handle, &e);
+  va_end(args);
+  return st;
 }
 
 void
 set_blank_id(SerdReader* reader, Ref ref, size_t buf_size)
 {
-	SerdNode*   node   = deref(reader, ref);
-	const char* prefix = reader->bprefix ? (const char*)reader->bprefix : "";
-	node->n_bytes = node->n_chars = (size_t)snprintf(
-		(char*)node->buf, buf_size, "%sb%u", prefix, reader->next_id++);
+  SerdNode*   node   = deref(reader, ref);
+  const char* prefix = reader->bprefix ? (const char*)reader->bprefix : "";
+  node->n_bytes = node->n_chars = (size_t)snprintf(
+    (char*)node->buf, buf_size, "%sb%u", prefix, reader->next_id++);
 }
 
 size_t
 genid_size(SerdReader* reader)
 {
-	return reader->bprefix_len + 1 + 10 + 1;  // + "b" + UINT32_MAX + \0
+  return reader->bprefix_len + 1 + 10 + 1; // + "b" + UINT32_MAX + \0
 }
 
 Ref
 blank_id(SerdReader* reader)
 {
-	Ref ref = push_node_padded(reader, genid_size(reader), SERD_BLANK, "", 0);
-	set_blank_id(reader, ref, genid_size(reader));
-	return ref;
+  Ref ref = push_node_padded(reader, genid_size(reader), SERD_BLANK, "", 0);
+  set_blank_id(reader, ref, genid_size(reader));
+  return ref;
 }
 
 /** fread-like wrapper for getc (which is faster). */
 static size_t
 serd_file_read_byte(void* buf, size_t size, size_t nmemb, void* stream)
 {
-	(void)size;
-	(void)nmemb;
-
-	const int c = getc((FILE*)stream);
-	if (c == EOF) {
-		*((uint8_t*)buf) = 0;
-		return 0;
-	}
-	*((uint8_t*)buf) = (uint8_t)c;
-	return 1;
+  (void)size;
+  (void)nmemb;
+
+  const int c = getc((FILE*)stream);
+  if (c == EOF) {
+    *((uint8_t*)buf) = 0;
+    return 0;
+  }
+  *((uint8_t*)buf) = (uint8_t)c;
+  return 1;
 }
 
 Ref
-push_node_padded(SerdReader* reader, size_t maxlen,
-                 SerdType type, const char* str, size_t n_bytes)
+push_node_padded(SerdReader* reader,
+                 size_t      maxlen,
+                 SerdType    type,
+                 const char* str,
+                 size_t      n_bytes)
 {
-	void* mem = serd_stack_push_aligned(
-		&reader->stack, sizeof(SerdNode) + maxlen + 1, sizeof(SerdNode));
+  void* mem = serd_stack_push_aligned(
+    &reader->stack, sizeof(SerdNode) + maxlen + 1, sizeof(SerdNode));
 
-	SerdNode* const node = (SerdNode*)mem;
-	node->n_bytes = node->n_chars = n_bytes;
-	node->flags   = 0;
-	node->type    = type;
-	node->buf     = NULL;
+  SerdNode* const node = (SerdNode*)mem;
+  node->n_bytes = node->n_chars = n_bytes;
+  node->flags                   = 0;
+  node->type                    = type;
+  node->buf                     = NULL;
 
-	uint8_t* buf = (uint8_t*)(node + 1);
-	memcpy(buf, str, n_bytes + 1);
+  uint8_t* buf = (uint8_t*)(node + 1);
+  memcpy(buf, str, n_bytes + 1);
 
 #ifdef SERD_STACK_CHECK
-	reader->allocs = (Ref*)realloc(
-		reader->allocs, sizeof(reader->allocs) * (++reader->n_allocs));
-	reader->allocs[reader->n_allocs - 1] = ((uint8_t*)mem - reader->stack.buf);
+  reader->allocs                       = (Ref*)realloc(reader->allocs,
+                                 sizeof(reader->allocs) * (++reader->n_allocs));
+  reader->allocs[reader->n_allocs - 1] = ((uint8_t*)mem - reader->stack.buf);
 #endif
-	return (Ref)((uint8_t*)node - reader->stack.buf);
+  return (Ref)((uint8_t*)node - reader->stack.buf);
 }
 
 Ref
 push_node(SerdReader* reader, SerdType type, const char* str, size_t n_bytes)
 {
-	return push_node_padded(reader, n_bytes, type, str, n_bytes);
+  return push_node_padded(reader, n_bytes, type, str, n_bytes);
 }
 
 SerdNode*
 deref(SerdReader* reader, const Ref ref)
 {
-	if (ref) {
-		SerdNode* node = (SerdNode*)(reader->stack.buf + ref);
-		node->buf = (uint8_t*)node + sizeof(SerdNode);
-		return node;
-	}
-	return NULL;
+  if (ref) {
+    SerdNode* node = (SerdNode*)(reader->stack.buf + ref);
+    node->buf      = (uint8_t*)node + sizeof(SerdNode);
+    return node;
+  }
+  return NULL;
 }
 
 Ref
 pop_node(SerdReader* reader, Ref ref)
 {
-	if (ref && ref != reader->rdf_first && ref != reader->rdf_rest
-	    && ref != reader->rdf_nil) {
+  if (ref && ref != reader->rdf_first && ref != reader->rdf_rest &&
+      ref != reader->rdf_nil) {
 #ifdef SERD_STACK_CHECK
-		SERD_STACK_ASSERT_TOP(reader, ref);
-		--reader->n_allocs;
+    SERD_STACK_ASSERT_TOP(reader, ref);
+    --reader->n_allocs;
 #endif
-		SerdNode* const node = deref(reader, ref);
-		uint8_t* const  top  = reader->stack.buf + reader->stack.size;
-		serd_stack_pop_aligned(&reader->stack, (size_t)(top - (uint8_t*)node));
-	}
-	return 0;
+    SerdNode* const node = deref(reader, ref);
+    uint8_t* const  top  = reader->stack.buf + reader->stack.size;
+    serd_stack_pop_aligned(&reader->stack, (size_t)(top - (uint8_t*)node));
+  }
+  return 0;
 }
 
 SerdStatus
 emit_statement(SerdReader* reader, ReadContext ctx, Ref o, Ref d, Ref l)
 {
-	SerdNode* graph = deref(reader, ctx.graph);
-	if (!graph && reader->default_graph.buf) {
-		graph = &reader->default_graph;
-	}
-
-	const SerdStatus st =
-	    !reader->statement_sink
-	        ? SERD_SUCCESS
-	        : reader->statement_sink(reader->handle,
-	                                 *ctx.flags,
-	                                 graph,
-	                                 deref(reader, ctx.subject),
-	                                 deref(reader, ctx.predicate),
-	                                 deref(reader, o),
-	                                 deref(reader, d),
-	                                 deref(reader, l));
-
-	*ctx.flags &= SERD_ANON_CONT|SERD_LIST_CONT;  // Preserve only cont flags
-	return st;
+  SerdNode* graph = deref(reader, ctx.graph);
+  if (!graph && reader->default_graph.buf) {
+    graph = &reader->default_graph;
+  }
+
+  const SerdStatus st = !reader->statement_sink
+                          ? SERD_SUCCESS
+                          : reader->statement_sink(reader->handle,
+                                                   *ctx.flags,
+                                                   graph,
+                                                   deref(reader, ctx.subject),
+                                                   deref(reader, ctx.predicate),
+                                                   deref(reader, o),
+                                                   deref(reader, d),
+                                                   deref(reader, l));
+
+  *ctx.flags &= SERD_ANON_CONT | SERD_LIST_CONT; // Preserve only cont flags
+  return st;
 }
 
 static SerdStatus
 read_statement(SerdReader* reader)
 {
-	return read_n3_statement(reader);
+  return read_n3_statement(reader);
 }
 
 static SerdStatus
 read_doc(SerdReader* reader)
 {
-	return ((reader->syntax == SERD_NQUADS) ? read_nquadsDoc(reader)
-	                                        : read_turtleTrigDoc(reader));
+  return ((reader->syntax == SERD_NQUADS) ? read_nquadsDoc(reader)
+                                          : read_turtleTrigDoc(reader));
 }
 
 SerdReader*
-serd_reader_new(SerdSyntax        syntax,
-                void*             handle,
-                void              (*free_handle)(void*),
+serd_reader_new(SerdSyntax syntax,
+                void*      handle,
+                void (*free_handle)(void*),
                 SerdBaseSink      base_sink,
                 SerdPrefixSink    prefix_sink,
                 SerdStatementSink statement_sink,
                 SerdEndSink       end_sink)
 {
-	SerdReader*  me  = (SerdReader*)calloc(1, sizeof(SerdReader));
-	me->handle           = handle;
-	me->free_handle      = free_handle;
-	me->base_sink        = base_sink;
-	me->prefix_sink      = prefix_sink;
-	me->statement_sink   = statement_sink;
-	me->end_sink         = end_sink;
-	me->default_graph    = SERD_NODE_NULL;
-	me->stack            = serd_stack_new(SERD_PAGE_SIZE);
-	me->syntax           = syntax;
-	me->next_id          = 1;
-	me->strict           = true;
-
-	me->rdf_first = push_node(me, SERD_URI, NS_RDF "first", 48);
-	me->rdf_rest  = push_node(me, SERD_URI, NS_RDF "rest", 47);
-	me->rdf_nil   = push_node(me, SERD_URI, NS_RDF "nil", 46);
-
-	return me;
+  SerdReader* me     = (SerdReader*)calloc(1, sizeof(SerdReader));
+  me->handle         = handle;
+  me->free_handle    = free_handle;
+  me->base_sink      = base_sink;
+  me->prefix_sink    = prefix_sink;
+  me->statement_sink = statement_sink;
+  me->end_sink       = end_sink;
+  me->default_graph  = SERD_NODE_NULL;
+  me->stack          = serd_stack_new(SERD_PAGE_SIZE);
+  me->syntax         = syntax;
+  me->next_id        = 1;
+  me->strict         = true;
+
+  me->rdf_first = push_node(me, SERD_URI, NS_RDF "first", 48);
+  me->rdf_rest  = push_node(me, SERD_URI, NS_RDF "rest", 47);
+  me->rdf_nil   = push_node(me, SERD_URI, NS_RDF "nil", 46);
+
+  return me;
 }
 
 void
 serd_reader_set_strict(SerdReader* reader, bool strict)
 {
-	reader->strict = strict;
+  reader->strict = strict;
 }
 
 void
@@ -211,98 +213,96 @@ serd_reader_set_error_sink(SerdReader*   reader,
                            SerdErrorSink error_sink,
                            void*         error_handle)
 {
-	reader->error_sink   = error_sink;
-	reader->error_handle = error_handle;
+  reader->error_sink   = error_sink;
+  reader->error_handle = error_handle;
 }
 
 void
 serd_reader_free(SerdReader* reader)
 {
-	if (!reader) {
-		return;
-	}
+  if (!reader) {
+    return;
+  }
 
-	pop_node(reader, reader->rdf_nil);
-	pop_node(reader, reader->rdf_rest);
-	pop_node(reader, reader->rdf_first);
-	serd_node_free(&reader->default_graph);
+  pop_node(reader, reader->rdf_nil);
+  pop_node(reader, reader->rdf_rest);
+  pop_node(reader, reader->rdf_first);
+  serd_node_free(&reader->default_graph);
 
 #ifdef SERD_STACK_CHECK
-	free(reader->allocs);
+  free(reader->allocs);
 #endif
-	free(reader->stack.buf);
-	free(reader->bprefix);
-	if (reader->free_handle) {
-		reader->free_handle(reader->handle);
-	}
-	free(reader);
+  free(reader->stack.buf);
+  free(reader->bprefix);
+  if (reader->free_handle) {
+    reader->free_handle(reader->handle);
+  }
+  free(reader);
 }
 
 void*
 serd_reader_get_handle(const SerdReader* reader)
 {
-	return reader->handle;
+  return reader->handle;
 }
 
 void
 serd_reader_add_blank_prefix(SerdReader* reader, const uint8_t* prefix)
 {
-	free(reader->bprefix);
-	reader->bprefix_len = 0;
-	reader->bprefix     = NULL;
-
-	const size_t prefix_len = prefix ? strlen((const char*)prefix) : 0;
-	if (prefix_len) {
-		reader->bprefix_len = prefix_len;
-		reader->bprefix     = (uint8_t*)malloc(reader->bprefix_len + 1);
-		memcpy(reader->bprefix, prefix, reader->bprefix_len + 1);
-	}
+  free(reader->bprefix);
+  reader->bprefix_len = 0;
+  reader->bprefix     = NULL;
+
+  const size_t prefix_len = prefix ? strlen((const char*)prefix) : 0;
+  if (prefix_len) {
+    reader->bprefix_len = prefix_len;
+    reader->bprefix     = (uint8_t*)malloc(reader->bprefix_len + 1);
+    memcpy(reader->bprefix, prefix, reader->bprefix_len + 1);
+  }
 }
 
 void
-serd_reader_set_default_graph(SerdReader*     reader,
-                              const SerdNode* graph)
+serd_reader_set_default_graph(SerdReader* reader, const SerdNode* graph)
 {
-	serd_node_free(&reader->default_graph);
-	reader->default_graph = serd_node_copy(graph);
+  serd_node_free(&reader->default_graph);
+  reader->default_graph = serd_node_copy(graph);
 }
 
 SerdStatus
-serd_reader_read_file(SerdReader*    reader,
-                      const uint8_t* uri)
+serd_reader_read_file(SerdReader* reader, const uint8_t* uri)
 {
-	uint8_t* const path = serd_file_uri_parse(uri, NULL);
-	if (!path) {
-		return SERD_ERR_BAD_ARG;
-	}
-
-	FILE* fd = serd_fopen((const char*)path, "rb");
-	if (!fd) {
-		serd_free(path);
-		return SERD_ERR_UNKNOWN;
-	}
-
-	SerdStatus ret = serd_reader_read_file_handle(reader, fd, path);
-	fclose(fd);
-	free(path);
-	return ret;
+  uint8_t* const path = serd_file_uri_parse(uri, NULL);
+  if (!path) {
+    return SERD_ERR_BAD_ARG;
+  }
+
+  FILE* fd = serd_fopen((const char*)path, "rb");
+  if (!fd) {
+    serd_free(path);
+    return SERD_ERR_UNKNOWN;
+  }
+
+  SerdStatus ret = serd_reader_read_file_handle(reader, fd, path);
+  fclose(fd);
+  free(path);
+  return ret;
 }
 
 static SerdStatus
 skip_bom(SerdReader* me)
 {
-	if (serd_byte_source_peek(&me->source) == 0xEF) {
-		serd_byte_source_advance(&me->source);
-		if (serd_byte_source_peek(&me->source) != 0xBB ||
-		    serd_byte_source_advance(&me->source) ||
-		    serd_byte_source_peek(&me->source) != 0xBF ||
-		    serd_byte_source_advance(&me->source)) {
-			r_err(me, SERD_ERR_BAD_SYNTAX, "corrupt byte order mark\n");
-			return SERD_ERR_BAD_SYNTAX;
-		}
-	}
-
-	return SERD_SUCCESS;
+  if (serd_byte_source_peek(&me->source) == 0xEF) {
+    serd_byte_source_advance(&me->source);
+    if (serd_byte_source_peek(&me->source) != 0xBB ||
+        serd_byte_source_advance(&me->source) ||
+        serd_byte_source_peek(&me->source) != 0xBF ||
+        serd_byte_source_advance(&me->source)) {
+      r_err(me, SERD_ERR_BAD_SYNTAX, "corrupt byte order mark\n");
+      return SERD_ERR_BAD_SYNTAX;
+    }
+  }
+
+  return SERD_SUCCESS;
 }
 
 SerdStatus
@@ -311,13 +311,13 @@ serd_reader_start_stream(SerdReader*    reader,
                          const uint8_t* name,
                          bool           bulk)
 {
-	return serd_reader_start_source_stream(
-		reader,
-		bulk ? (SerdSource)fread : serd_file_read_byte,
-		(SerdStreamErrorFunc)ferror,
-		file,
-		name,
-		bulk ? SERD_PAGE_SIZE : 1);
+  return serd_reader_start_source_stream(reader,
+                                         bulk ? (SerdSource)fread
+                                              : serd_file_read_byte,
+                                         (SerdStreamErrorFunc)ferror,
+                                         file,
+                                         name,
+                                         bulk ? SERD_PAGE_SIZE : 1);
 }
 
 SerdStatus
@@ -328,46 +328,46 @@ serd_reader_start_source_stream(SerdReader*         reader,
                                 const uint8_t*      name,
                                 size_t              page_size)
 {
-	return serd_byte_source_open_source(
-		&reader->source, read_func, error_func, stream, name, page_size);
+  return serd_byte_source_open_source(
+    &reader->source, read_func, error_func, stream, name, page_size);
 }
 
 static SerdStatus
 serd_reader_prepare(SerdReader* reader)
 {
-	SerdStatus st = serd_byte_source_prepare(&reader->source);
-	if (st == SERD_SUCCESS) {
-		st = skip_bom(reader);
-	} else if (st == SERD_FAILURE) {
-		reader->source.eof = true;
-	} else {
-		r_err(reader, st, "read error: %s\n", strerror(errno));
-	}
-	return st;
+  SerdStatus st = serd_byte_source_prepare(&reader->source);
+  if (st == SERD_SUCCESS) {
+    st = skip_bom(reader);
+  } else if (st == SERD_FAILURE) {
+    reader->source.eof = true;
+  } else {
+    r_err(reader, st, "read error: %s\n", strerror(errno));
+  }
+  return st;
 }
 
 SerdStatus
 serd_reader_read_chunk(SerdReader* reader)
 {
-	SerdStatus st = SERD_SUCCESS;
-	if (!reader->source.prepared) {
-		st = serd_reader_prepare(reader);
-	} else if (reader->source.eof) {
-		st = serd_byte_source_advance(&reader->source);
-	}
-
-	if (peek_byte(reader) == 0) {
-		// Skip leading null byte, for reading from a null-delimited socket
-		eat_byte_safe(reader, 0);
-	}
-
-	return st ? st : read_statement(reader);
+  SerdStatus st = SERD_SUCCESS;
+  if (!reader->source.prepared) {
+    st = serd_reader_prepare(reader);
+  } else if (reader->source.eof) {
+    st = serd_byte_source_advance(&reader->source);
+  }
+
+  if (peek_byte(reader) == 0) {
+    // Skip leading null byte, for reading from a null-delimited socket
+    eat_byte_safe(reader, 0);
+  }
+
+  return st ? st : read_statement(reader);
 }
 
 SerdStatus
 serd_reader_end_stream(SerdReader* reader)
 {
-	return serd_byte_source_close(&reader->source);
+  return serd_byte_source_close(&reader->source);
 }
 
 SerdStatus
@@ -375,9 +375,12 @@ serd_reader_read_file_handle(SerdReader*    reader,
                              FILE*          file,
                              const uint8_t* name)
 {
-	return serd_reader_read_source(
-		reader, (SerdSource)fread, (SerdStreamErrorFunc)ferror,
-		file, name, SERD_PAGE_SIZE);
+  return serd_reader_read_source(reader,
+                                 (SerdSource)fread,
+                                 (SerdStreamErrorFunc)ferror,
+                                 file,
+                                 name,
+                                 SERD_PAGE_SIZE);
 }
 
 SerdStatus
@@ -388,33 +391,33 @@ serd_reader_read_source(SerdReader*         reader,
                         const uint8_t*      name,
                         size_t              page_size)
 {
-	SerdStatus st = serd_reader_start_source_stream(
-		reader, source, error, stream, name, page_size);
+  SerdStatus st = serd_reader_start_source_stream(
+    reader, source, error, stream, name, page_size);
 
-	if (st || (st = serd_reader_prepare(reader))) {
-		serd_reader_end_stream(reader);
-		return st;
-	}
+  if (st || (st = serd_reader_prepare(reader))) {
+    serd_reader_end_stream(reader);
+    return st;
+  }
 
-	if ((st = read_doc(reader))) {
-		serd_reader_end_stream(reader);
-		return st;
-	}
+  if ((st = read_doc(reader))) {
+    serd_reader_end_stream(reader);
+    return st;
+  }
 
-	return serd_reader_end_stream(reader);
+  return serd_reader_end_stream(reader);
 }
 
 SerdStatus
 serd_reader_read_string(SerdReader* reader, const uint8_t* utf8)
 {
-	serd_byte_source_open_string(&reader->source, utf8);
+  serd_byte_source_open_string(&reader->source, utf8);
 
-	SerdStatus st = serd_reader_prepare(reader);
-	if (!st) {
-		st = read_doc(reader);
-	}
+  SerdStatus st = serd_reader_prepare(reader);
+  if (!st) {
+    st = read_doc(reader);
+  }
 
-	serd_byte_source_close(&reader->source);
+  serd_byte_source_close(&reader->source);
 
-	return st;
+  return st;
 }
diff --git a/src/reader.h b/src/reader.h
index 166e2137..85a2f109 100644
--- a/src/reader.h
+++ b/src/reader.h
@@ -28,16 +28,16 @@
 #include <stdio.h>
 
 #if defined(__GNUC__)
-#    define SERD_LOG_FUNC(fmt, arg1) __attribute__((format(printf, fmt, arg1)))
+#  define SERD_LOG_FUNC(fmt, arg1) __attribute__((format(printf, fmt, arg1)))
 #else
-#    define SERD_LOG_FUNC(fmt, arg1)
+#  define SERD_LOG_FUNC(fmt, arg1)
 #endif
 
 #ifdef SERD_STACK_CHECK
-#    define SERD_STACK_ASSERT_TOP(reader, ref) \
-            assert(ref == reader->allocs[reader->n_allocs - 1]);
+#  define SERD_STACK_ASSERT_TOP(reader, ref) \
+    assert(ref == reader->allocs[reader->n_allocs - 1]);
 #else
-#    define SERD_STACK_ASSERT_TOP(reader, ref)
+#  define SERD_STACK_ASSERT_TOP(reader, ref)
 #endif
 
 /* Reference to a node in the stack (we can not use pointers since the
@@ -46,40 +46,40 @@
 typedef size_t Ref;
 
 typedef struct {
-	Ref                 graph;
-	Ref                 subject;
-	Ref                 predicate;
-	Ref                 object;
-	Ref                 datatype;
-	Ref                 lang;
-	SerdStatementFlags* flags;
+  Ref                 graph;
+  Ref                 subject;
+  Ref                 predicate;
+  Ref                 object;
+  Ref                 datatype;
+  Ref                 lang;
+  SerdStatementFlags* flags;
 } ReadContext;
 
 struct SerdReaderImpl {
-	void*             handle;
-	void              (*free_handle)(void* ptr);
-	SerdBaseSink      base_sink;
-	SerdPrefixSink    prefix_sink;
-	SerdStatementSink statement_sink;
-	SerdEndSink       end_sink;
-	SerdErrorSink     error_sink;
-	void*             error_handle;
-	Ref               rdf_first;
-	Ref               rdf_rest;
-	Ref               rdf_nil;
-	SerdNode          default_graph;
-	SerdByteSource    source;
-	SerdStack         stack;
-	SerdSyntax        syntax;
-	unsigned          next_id;
-	uint8_t*          buf;
-	uint8_t*          bprefix;
-	size_t            bprefix_len;
-	bool              strict;     ///< True iff strict parsing
-	bool              seen_genid;
+  void* handle;
+  void (*free_handle)(void* ptr);
+  SerdBaseSink      base_sink;
+  SerdPrefixSink    prefix_sink;
+  SerdStatementSink statement_sink;
+  SerdEndSink       end_sink;
+  SerdErrorSink     error_sink;
+  void*             error_handle;
+  Ref               rdf_first;
+  Ref               rdf_rest;
+  Ref               rdf_nil;
+  SerdNode          default_graph;
+  SerdByteSource    source;
+  SerdStack         stack;
+  SerdSyntax        syntax;
+  unsigned          next_id;
+  uint8_t*          buf;
+  uint8_t*          bprefix;
+  size_t            bprefix_len;
+  bool              strict; ///< True iff strict parsing
+  bool              seen_genid;
 #ifdef SERD_STACK_CHECK
-	Ref*              allocs;     ///< Stack of push offsets
-	size_t            n_allocs;   ///< Number of stack pushes
+  Ref*   allocs;   ///< Stack of push offsets
+  size_t n_allocs; ///< Number of stack pushes
 #endif
 };
 
@@ -87,98 +87,110 @@ SERD_LOG_FUNC(3, 4)
 SerdStatus
 r_err(SerdReader* reader, SerdStatus st, const char* fmt, ...);
 
-Ref push_node_padded(SerdReader* reader,
-                     size_t      maxlen,
-                     SerdType    type,
-                     const char* str,
-                     size_t      n_bytes);
+Ref
+push_node_padded(SerdReader* reader,
+                 size_t      maxlen,
+                 SerdType    type,
+                 const char* str,
+                 size_t      n_bytes);
 
-Ref push_node(SerdReader* reader,
-              SerdType    type,
-              const char* str,
-              size_t      n_bytes);
+Ref
+push_node(SerdReader* reader, SerdType type, const char* str, size_t n_bytes);
 
-SERD_PURE_FUNC size_t genid_size(SerdReader* reader);
-Ref                   blank_id(SerdReader* reader);
-void                  set_blank_id(SerdReader* reader, Ref ref, size_t buf_size);
+SERD_PURE_FUNC size_t
+genid_size(SerdReader* reader);
 
-SerdNode* deref(SerdReader* reader, Ref ref);
+Ref
+blank_id(SerdReader* reader);
 
-Ref pop_node(SerdReader* reader, Ref ref);
+void
+set_blank_id(SerdReader* reader, Ref ref, size_t buf_size);
+
+SerdNode*
+deref(SerdReader* reader, Ref ref);
+
+Ref
+pop_node(SerdReader* reader, Ref ref);
 
 SerdStatus
 emit_statement(SerdReader* reader, ReadContext ctx, Ref o, Ref d, Ref l);
 
-SerdStatus read_n3_statement(SerdReader* reader);
-SerdStatus read_nquadsDoc(SerdReader* reader);
-SerdStatus read_turtleTrigDoc(SerdReader* reader);
+SerdStatus
+read_n3_statement(SerdReader* reader);
+
+SerdStatus
+read_nquadsDoc(SerdReader* reader);
+
+SerdStatus
+read_turtleTrigDoc(SerdReader* reader);
 
 static inline int
 peek_byte(SerdReader* reader)
 {
-	SerdByteSource* source = &reader->source;
+  SerdByteSource* source = &reader->source;
 
-	return source->eof ? EOF : (int)source->read_buf[source->read_head];
+  return source->eof ? EOF : (int)source->read_buf[source->read_head];
 }
 
 static inline int
 eat_byte_safe(SerdReader* reader, const int byte)
 {
-	(void)byte;
+  (void)byte;
 
-	const int c = peek_byte(reader);
-	assert(c == byte);
+  const int c = peek_byte(reader);
+  assert(c == byte);
 
-	serd_byte_source_advance(&reader->source);
-	return c;
+  serd_byte_source_advance(&reader->source);
+  return c;
 }
 
 static inline int
 eat_byte_check(SerdReader* reader, const int byte)
 {
-	const int c = peek_byte(reader);
-	if (c != byte) {
-		r_err(reader, SERD_ERR_BAD_SYNTAX,
-		      "expected `%c', not `%c'\n", byte, c);
-		return 0;
-	}
-	return eat_byte_safe(reader, byte);
+  const int c = peek_byte(reader);
+  if (c != byte) {
+    r_err(reader, SERD_ERR_BAD_SYNTAX, "expected `%c', not `%c'\n", byte, c);
+    return 0;
+  }
+  return eat_byte_safe(reader, byte);
 }
 
 static inline SerdStatus
 eat_string(SerdReader* reader, const char* str, unsigned n)
 {
-	for (unsigned i = 0; i < n; ++i) {
-		if (!eat_byte_check(reader, ((const uint8_t*)str)[i])) {
-			return SERD_ERR_BAD_SYNTAX;
-		}
-	}
-	return SERD_SUCCESS;
+  for (unsigned i = 0; i < n; ++i) {
+    if (!eat_byte_check(reader, ((const uint8_t*)str)[i])) {
+      return SERD_ERR_BAD_SYNTAX;
+    }
+  }
+  return SERD_SUCCESS;
 }
 
 static inline SerdStatus
 push_byte(SerdReader* reader, Ref ref, const int c)
 {
-	assert(c != EOF);
-	SERD_STACK_ASSERT_TOP(reader, ref);
-
-	uint8_t* const  s    = (uint8_t*)serd_stack_push(&reader->stack, 1);
-	SerdNode* const node = (SerdNode*)(reader->stack.buf + ref);
-	++node->n_bytes;
-	if (!(c & 0x80)) {  // Starts with 0 bit, start of new character
-		++node->n_chars;
-	}
-	*(s - 1) = (uint8_t)c;
-	*s       = '\0';
-	return SERD_SUCCESS;
+  assert(c != EOF);
+  SERD_STACK_ASSERT_TOP(reader, ref);
+
+  uint8_t* const  s    = (uint8_t*)serd_stack_push(&reader->stack, 1);
+  SerdNode* const node = (SerdNode*)(reader->stack.buf + ref);
+
+  ++node->n_bytes;
+  if (!(c & 0x80)) { // Starts with 0 bit, start of new character
+    ++node->n_chars;
+  }
+
+  *(s - 1) = (uint8_t)c;
+  *s       = '\0';
+  return SERD_SUCCESS;
 }
 
 static inline void
 push_bytes(SerdReader* reader, Ref ref, const uint8_t* bytes, unsigned len)
 {
-	for (unsigned i = 0; i < len; ++i) {
-		push_byte(reader, ref, bytes[i]);
-	}
+  for (unsigned i = 0; i < len; ++i) {
+    push_byte(reader, ref, bytes[i]);
+  }
 }
 
 #endif // SERD_READER_H
diff --git a/src/serd_internal.h b/src/serd_internal.h
index 95c3b121..af9e7710 100644
--- a/src/serd_internal.h
+++ b/src/serd_internal.h
@@ -27,7 +27,7 @@
 #define SERD_PAGE_SIZE 4096
 
 #ifndef MIN
-#    define MIN(a, b) (((a) < (b)) ? (a) : (b))
+#  define MIN(a, b) (((a) < (b)) ? (a) : (b))
 #endif
 
 /* Error reporting */
@@ -35,12 +35,12 @@
 static inline void
 serd_error(SerdErrorSink error_sink, void* handle, const SerdError* e)
 {
-	if (error_sink) {
-		error_sink(handle, e);
-	} else {
-		fprintf(stderr, "error: %s:%u:%u: ", e->filename, e->line, e->col);
-		vfprintf(stderr, e->fmt, *e->args);
-	}
+  if (error_sink) {
+    error_sink(handle, e);
+  } else {
+    fprintf(stderr, "error: %s:%u:%u: ", e->filename, e->line, e->col);
+    vfprintf(stderr, e->fmt, *e->args);
+  }
 }
 
-#endif  // SERD_INTERNAL_H
+#endif // SERD_INTERNAL_H
diff --git a/src/serdi.c b/src/serdi.c
index 69304cad..44644ff4 100644
--- a/src/serdi.c
+++ b/src/serdi.c
@@ -22,13 +22,13 @@
 #include "serd/serd.h"
 
 #ifdef _WIN32
-#define WIN32_LEAN_AND_MEAN 1
-#include <fcntl.h>
-#include <io.h>
+#  define WIN32_LEAN_AND_MEAN 1
+#  include <fcntl.h>
+#  include <io.h>
 #endif
 
 #if defined(HAVE_POSIX_FADVISE) && defined(HAVE_FILENO)
-#include <fcntl.h>
+#  include <fcntl.h>
 #endif
 
 #include <errno.h>
@@ -38,114 +38,114 @@
 #include <stdlib.h>
 #include <string.h>
 
-#define SERDI_ERROR(msg)       fprintf(stderr, "serdi: " msg)
+#define SERDI_ERROR(msg) fprintf(stderr, "serdi: " msg)
 #define SERDI_ERRORF(fmt, ...) fprintf(stderr, "serdi: " fmt, __VA_ARGS__)
 
 typedef struct {
-	SerdSyntax  syntax;
-	const char* name;
-	const char* extension;
+  SerdSyntax  syntax;
+  const char* name;
+  const char* extension;
 } Syntax;
 
-static const Syntax syntaxes[] = {
-	{SERD_TURTLE,   "turtle",   ".ttl"},
-	{SERD_NTRIPLES, "ntriples", ".nt"},
-	{SERD_NQUADS,   "nquads",   ".nq"},
-	{SERD_TRIG,     "trig",     ".trig"},
-	{(SerdSyntax)0, NULL, NULL}
-};
+static const Syntax syntaxes[] = {{SERD_TURTLE, "turtle", ".ttl"},
+                                  {SERD_NTRIPLES, "ntriples", ".nt"},
+                                  {SERD_NQUADS, "nquads", ".nq"},
+                                  {SERD_TRIG, "trig", ".trig"},
+                                  {(SerdSyntax)0, NULL, NULL}};
 
 static SerdSyntax
 get_syntax(const char* name)
 {
-	for (const Syntax* s = syntaxes; s->name; ++s) {
-		if (!serd_strncasecmp(s->name, name, strlen(name))) {
-			return s->syntax;
-		}
-	}
-	SERDI_ERRORF("unknown syntax `%s'\n", name);
-	return (SerdSyntax)0;
+  for (const Syntax* s = syntaxes; s->name; ++s) {
+    if (!serd_strncasecmp(s->name, name, strlen(name))) {
+      return s->syntax;
+    }
+  }
+
+  SERDI_ERRORF("unknown syntax `%s'\n", name);
+  return (SerdSyntax)0;
 }
 
 static SERD_PURE_FUNC SerdSyntax
 guess_syntax(const char* filename)
 {
-	const char* ext = strrchr(filename, '.');
-	if (ext) {
-		for (const Syntax* s = syntaxes; s->name; ++s) {
-			if (!serd_strncasecmp(s->extension, ext, strlen(ext))) {
-				return s->syntax;
-			}
-		}
-	}
-	return (SerdSyntax)0;
+  const char* ext = strrchr(filename, '.');
+  if (ext) {
+    for (const Syntax* s = syntaxes; s->name; ++s) {
+      if (!serd_strncasecmp(s->extension, ext, strlen(ext))) {
+        return s->syntax;
+      }
+    }
+  }
+
+  return (SerdSyntax)0;
 }
 
 static int
 print_version(void)
 {
-	printf("serdi " SERD_VERSION " <http://drobilla.net/software/serd>\n");
-	printf("Copyright 2011-2020 David Robillard <http://drobilla.net>.\n"
-	       "License: <http://www.opensource.org/licenses/isc>\n"
-	       "This is free software; you are free to change and redistribute it."
-	       "\nThere is NO WARRANTY, to the extent permitted by law.\n");
-	return 0;
+  printf("serdi " SERD_VERSION " <http://drobilla.net/software/serd>\n");
+  printf("Copyright 2011-2020 David Robillard <http://drobilla.net>.\n"
+         "License: <http://www.opensource.org/licenses/isc>\n"
+         "This is free software; you are free to change and redistribute it."
+         "\nThere is NO WARRANTY, to the extent permitted by law.\n");
+  return 0;
 }
 
 static int
 print_usage(const char* name, bool error)
 {
-	FILE* const os = error ? stderr : stdout;
-	fprintf(os, "%s", error ? "\n" : "");
-	fprintf(os, "Usage: %s [OPTION]... INPUT [BASE_URI]\n", name);
-	fprintf(os, "Read and write RDF syntax.\n");
-	fprintf(os, "Use - for INPUT to read from standard input.\n\n");
-	fprintf(os, "  -a           Write ASCII output if possible.\n");
-	fprintf(os, "  -b           Fast bulk output for large serialisations.\n");
-	fprintf(os, "  -c PREFIX    Chop PREFIX from matching blank node IDs.\n");
-	fprintf(os, "  -e           Eat input one character at a time.\n");
-	fprintf(os, "  -f           Keep full URIs in input (don't qualify).\n");
-	fprintf(os, "  -h           Display this help and exit.\n");
-	fprintf(os, "  -i SYNTAX    Input syntax: turtle/ntriples/trig/nquads.\n");
-	fprintf(os, "  -l           Lax (non-strict) parsing.\n");
-	fprintf(os, "  -o SYNTAX    Output syntax: turtle/ntriples/nquads.\n");
-	fprintf(os, "  -p PREFIX    Add PREFIX to blank node IDs.\n");
-	fprintf(os, "  -q           Suppress all output except data.\n");
-	fprintf(os, "  -r ROOT_URI  Keep relative URIs within ROOT_URI.\n");
-	fprintf(os, "  -s INPUT     Parse INPUT as string (terminates options).\n");
-	fprintf(os, "  -v           Display version information and exit.\n");
-	return error ? 1 : 0;
+  FILE* const os = error ? stderr : stdout;
+  fprintf(os, "%s", error ? "\n" : "");
+  fprintf(os, "Usage: %s [OPTION]... INPUT [BASE_URI]\n", name);
+  fprintf(os, "Read and write RDF syntax.\n");
+  fprintf(os, "Use - for INPUT to read from standard input.\n\n");
+  fprintf(os, "  -a           Write ASCII output if possible.\n");
+  fprintf(os, "  -b           Fast bulk output for large serialisations.\n");
+  fprintf(os, "  -c PREFIX    Chop PREFIX from matching blank node IDs.\n");
+  fprintf(os, "  -e           Eat input one character at a time.\n");
+  fprintf(os, "  -f           Keep full URIs in input (don't qualify).\n");
+  fprintf(os, "  -h           Display this help and exit.\n");
+  fprintf(os, "  -i SYNTAX    Input syntax: turtle/ntriples/trig/nquads.\n");
+  fprintf(os, "  -l           Lax (non-strict) parsing.\n");
+  fprintf(os, "  -o SYNTAX    Output syntax: turtle/ntriples/nquads.\n");
+  fprintf(os, "  -p PREFIX    Add PREFIX to blank node IDs.\n");
+  fprintf(os, "  -q           Suppress all output except data.\n");
+  fprintf(os, "  -r ROOT_URI  Keep relative URIs within ROOT_URI.\n");
+  fprintf(os, "  -s INPUT     Parse INPUT as string (terminates options).\n");
+  fprintf(os, "  -v           Display version information and exit.\n");
+  return error ? 1 : 0;
 }
 
 static int
 missing_arg(const char* name, char opt)
 {
-	SERDI_ERRORF("option requires an argument -- '%c'\n", opt);
-	return print_usage(name, true);
+  SERDI_ERRORF("option requires an argument -- '%c'\n", opt);
+  return print_usage(name, true);
 }
 
 static SerdStatus
 quiet_error_sink(void* handle, const SerdError* e)
 {
-	(void)handle;
-	(void)e;
-	return SERD_SUCCESS;
+  (void)handle;
+  (void)e;
+  return SERD_SUCCESS;
 }
 
 static inline FILE*
 serd_fopen(const char* path, const char* mode)
 {
-	FILE* fd = fopen(path, mode);
-	if (!fd) {
-		SERDI_ERRORF("failed to open file %s (%s)\n", path, strerror(errno));
-		return NULL;
-	}
+  FILE* fd = fopen(path, mode);
+  if (!fd) {
+    SERDI_ERRORF("failed to open file %s (%s)\n", path, strerror(errno));
+    return NULL;
+  }
 
 #if defined(HAVE_POSIX_FADVISE) && defined(HAVE_FILENO)
-	posix_fadvise(fileno(fd), 0, 0, POSIX_FADV_SEQUENTIAL|POSIX_FADV_NOREUSE);
+  posix_fadvise(fileno(fd), 0, 0, POSIX_FADV_SEQUENTIAL | POSIX_FADV_NOREUSE);
 #endif
 
-	return fd;
+  return fd;
 }
 
 static SerdStyle
@@ -155,219 +155,221 @@ choose_style(const SerdSyntax input_syntax,
              const bool       bulk_write,
              const bool       full_uris)
 {
-	unsigned output_style = 0u;
-	if (output_syntax == SERD_NTRIPLES || ascii) {
-		output_style |= SERD_STYLE_ASCII;
-	} else if (output_syntax == SERD_TURTLE) {
-		output_style |= SERD_STYLE_ABBREVIATED;
-		if (!full_uris) {
-			output_style |= SERD_STYLE_CURIED;
-		}
-	}
-
-	if ((input_syntax == SERD_TURTLE || input_syntax == SERD_TRIG) ||
-	    (output_style & SERD_STYLE_CURIED)) {
-		// Base URI may change and/or we're abbreviating URIs, so must resolve
-		output_style |= SERD_STYLE_RESOLVED;
-	}
-
-	if (bulk_write) {
-		output_style |= SERD_STYLE_BULK;
-	}
-
-	return (SerdStyle)output_style;
+  unsigned output_style = 0u;
+  if (output_syntax == SERD_NTRIPLES || ascii) {
+    output_style |= SERD_STYLE_ASCII;
+  } else if (output_syntax == SERD_TURTLE) {
+    output_style |= SERD_STYLE_ABBREVIATED;
+    if (!full_uris) {
+      output_style |= SERD_STYLE_CURIED;
+    }
+  }
+
+  if ((input_syntax == SERD_TURTLE || input_syntax == SERD_TRIG) ||
+      (output_style & SERD_STYLE_CURIED)) {
+    // Base URI may change and/or we're abbreviating URIs, so must resolve
+    output_style |= SERD_STYLE_RESOLVED;
+  }
+
+  if (bulk_write) {
+    output_style |= SERD_STYLE_BULK;
+  }
+
+  return (SerdStyle)output_style;
 }
 
 int
 main(int argc, char** argv)
 {
-	if (argc < 2) {
-		return print_usage(argv[0], true);
-	}
-
-	FILE*          in_fd         = NULL;
-	SerdSyntax     input_syntax  = (SerdSyntax)0;
-	SerdSyntax     output_syntax = (SerdSyntax)0;
-	bool           from_file     = true;
-	bool           ascii         = false;
-	bool           bulk_read     = true;
-	bool           bulk_write    = false;
-	bool           full_uris     = false;
-	bool           lax           = false;
-	bool           quiet         = false;
-	const uint8_t* in_name       = NULL;
-	const uint8_t* add_prefix    = NULL;
-	const uint8_t* chop_prefix   = NULL;
-	const uint8_t* root_uri      = NULL;
-	int            a             = 1;
-	for (; a < argc && argv[a][0] == '-'; ++a) {
-		if (argv[a][1] == '\0') {
-			in_name = (const uint8_t*)"(stdin)";
-			in_fd   = stdin;
-			break;
-		}
-
-		if (argv[a][1] == 'a') {
-			ascii = true;
-		} else if (argv[a][1] == 'b') {
-			bulk_write = true;
-		} else if (argv[a][1] == 'e') {
-			bulk_read = false;
-		} else if (argv[a][1] == 'f') {
-			full_uris = true;
-		} else if (argv[a][1] == 'h') {
-			return print_usage(argv[0], false);
-		} else if (argv[a][1] == 'l') {
-			lax = true;
-		} else if (argv[a][1] == 'q') {
-			quiet = true;
-		} else if (argv[a][1] == 'v') {
-			return print_version();
-		} else if (argv[a][1] == 's') {
-			in_name = (const uint8_t*)"(string)";
-			from_file = false;
-			++a;
-			break;
-		} else if (argv[a][1] == 'i') {
-			if (++a == argc) {
-				return missing_arg(argv[0], 'i');
-			}
-
-			if (!(input_syntax = get_syntax(argv[a]))) {
-				return print_usage(argv[0], true);
-			}
-		} else if (argv[a][1] == 'o') {
-			if (++a == argc) {
-				return missing_arg(argv[0], 'o');
-			}
-
-			if (!(output_syntax = get_syntax(argv[a]))) {
-				return print_usage(argv[0], true);
-			}
-		} else if (argv[a][1] == 'p') {
-			if (++a == argc) {
-				return missing_arg(argv[0], 'p');
-			}
-
-			add_prefix = (const uint8_t*)argv[a];
-		} else if (argv[a][1] == 'c') {
-			if (++a == argc) {
-				return missing_arg(argv[0], 'c');
-			}
-
-			chop_prefix = (const uint8_t*)argv[a];
-		} else if (argv[a][1] == 'r') {
-			if (++a == argc) {
-				return missing_arg(argv[0], 'r');
-			}
-
-			root_uri = (const uint8_t*)argv[a];
-		} else {
-			SERDI_ERRORF("invalid option -- '%s'\n", argv[a] + 1);
-			return print_usage(argv[0], true);
-		}
-	}
-
-	if (a == argc) {
-		SERDI_ERROR("missing input\n");
-		return 1;
-	}
+  if (argc < 2) {
+    return print_usage(argv[0], true);
+  }
+
+  FILE*          in_fd         = NULL;
+  SerdSyntax     input_syntax  = (SerdSyntax)0;
+  SerdSyntax     output_syntax = (SerdSyntax)0;
+  bool           from_file     = true;
+  bool           ascii         = false;
+  bool           bulk_read     = true;
+  bool           bulk_write    = false;
+  bool           full_uris     = false;
+  bool           lax           = false;
+  bool           quiet         = false;
+  const uint8_t* in_name       = NULL;
+  const uint8_t* add_prefix    = NULL;
+  const uint8_t* chop_prefix   = NULL;
+  const uint8_t* root_uri      = NULL;
+  int            a             = 1;
+  for (; a < argc && argv[a][0] == '-'; ++a) {
+    if (argv[a][1] == '\0') {
+      in_name = (const uint8_t*)"(stdin)";
+      in_fd   = stdin;
+      break;
+    }
+
+    if (argv[a][1] == 'a') {
+      ascii = true;
+    } else if (argv[a][1] == 'b') {
+      bulk_write = true;
+    } else if (argv[a][1] == 'e') {
+      bulk_read = false;
+    } else if (argv[a][1] == 'f') {
+      full_uris = true;
+    } else if (argv[a][1] == 'h') {
+      return print_usage(argv[0], false);
+    } else if (argv[a][1] == 'l') {
+      lax = true;
+    } else if (argv[a][1] == 'q') {
+      quiet = true;
+    } else if (argv[a][1] == 'v') {
+      return print_version();
+    } else if (argv[a][1] == 's') {
+      in_name   = (const uint8_t*)"(string)";
+      from_file = false;
+      ++a;
+      break;
+    } else if (argv[a][1] == 'i') {
+      if (++a == argc) {
+        return missing_arg(argv[0], 'i');
+      }
+
+      if (!(input_syntax = get_syntax(argv[a]))) {
+        return print_usage(argv[0], true);
+      }
+    } else if (argv[a][1] == 'o') {
+      if (++a == argc) {
+        return missing_arg(argv[0], 'o');
+      }
+
+      if (!(output_syntax = get_syntax(argv[a]))) {
+        return print_usage(argv[0], true);
+      }
+    } else if (argv[a][1] == 'p') {
+      if (++a == argc) {
+        return missing_arg(argv[0], 'p');
+      }
+
+      add_prefix = (const uint8_t*)argv[a];
+    } else if (argv[a][1] == 'c') {
+      if (++a == argc) {
+        return missing_arg(argv[0], 'c');
+      }
+
+      chop_prefix = (const uint8_t*)argv[a];
+    } else if (argv[a][1] == 'r') {
+      if (++a == argc) {
+        return missing_arg(argv[0], 'r');
+      }
+
+      root_uri = (const uint8_t*)argv[a];
+    } else {
+      SERDI_ERRORF("invalid option -- '%s'\n", argv[a] + 1);
+      return print_usage(argv[0], true);
+    }
+  }
+
+  if (a == argc) {
+    SERDI_ERROR("missing input\n");
+    return 1;
+  }
 
 #ifdef _WIN32
-	_setmode(_fileno(stdin), _O_BINARY);
-	_setmode(_fileno(stdout), _O_BINARY);
+  _setmode(_fileno(stdin), _O_BINARY);
+  _setmode(_fileno(stdout), _O_BINARY);
 #endif
 
-	uint8_t*       input_path = NULL;
-	const uint8_t* input      = (const uint8_t*)argv[a++];
-	if (from_file) {
-		in_name = in_name ? in_name : input;
-		if (!in_fd) {
-			if (!strncmp((const char*)input, "file:", 5)) {
-				input_path = serd_file_uri_parse(input, NULL);
-				input      = input_path;
-			}
-			if (!input || !(in_fd = serd_fopen((const char*)input, "rb"))) {
-				return 1;
-			}
-		}
-	}
-
-	if (!input_syntax && !(input_syntax = guess_syntax((const char*)in_name))) {
-		input_syntax = SERD_TRIG;
-	}
-
-	if (!output_syntax) {
-		output_syntax = (
-			(input_syntax == SERD_TURTLE || input_syntax == SERD_NTRIPLES)
-			? SERD_NTRIPLES
-			: SERD_NQUADS);
-	}
-
-	const SerdStyle output_style =
-	    choose_style(input_syntax, output_syntax, ascii, bulk_write, full_uris);
-
-	SerdURI  base_uri = SERD_URI_NULL;
-	SerdNode base     = SERD_NODE_NULL;
-	if (a < argc) {  // Base URI given on command line
-		base = serd_node_new_uri_from_string(
-			(const uint8_t*)argv[a], NULL, &base_uri);
-	} else if (from_file && in_fd != stdin) {  // Use input file URI
-		base = serd_node_new_file_uri(input, NULL, &base_uri, true);
-	}
-
-	FILE* const    out_fd = stdout;
-	SerdEnv* const env    = serd_env_new(&base);
-
-	SerdWriter* const writer = serd_writer_new(
-	    output_syntax, output_style, env, &base_uri, serd_file_sink, out_fd);
-
-	SerdReader* const reader = serd_reader_new(
-		input_syntax, writer, NULL,
-		(SerdBaseSink)serd_writer_set_base_uri,
-		(SerdPrefixSink)serd_writer_set_prefix,
-		(SerdStatementSink)serd_writer_write_statement,
-		(SerdEndSink)serd_writer_end_anon);
-
-	serd_reader_set_strict(reader, !lax);
-	if (quiet) {
-		serd_reader_set_error_sink(reader, quiet_error_sink, NULL);
-		serd_writer_set_error_sink(writer, quiet_error_sink, NULL);
-	}
-
-	SerdNode root = serd_node_from_string(SERD_URI, root_uri);
-	serd_writer_set_root_uri(writer, &root);
-	serd_writer_chop_blank_prefix(writer, chop_prefix);
-	serd_reader_add_blank_prefix(reader, add_prefix);
-
-	SerdStatus st = SERD_SUCCESS;
-	if (!from_file) {
-		st = serd_reader_read_string(reader, input);
-	} else if (bulk_read) {
-		st = serd_reader_read_file_handle(reader, in_fd, in_name);
-	} else {
-		st = serd_reader_start_stream(reader, in_fd, in_name, false);
-		while (!st) {
-			st = serd_reader_read_chunk(reader);
-		}
-		serd_reader_end_stream(reader);
-	}
-
-	serd_reader_free(reader);
-	serd_writer_finish(writer);
-	serd_writer_free(writer);
-	serd_env_free(env);
-	serd_node_free(&base);
-	free(input_path);
-
-	if (from_file) {
-		fclose(in_fd);
-	}
-
-	if (fclose(out_fd)) {
-		perror("serdi: write error");
-		st = SERD_ERR_UNKNOWN;
-	}
-
-	return (st > SERD_FAILURE) ? 1 : 0;
+  uint8_t*       input_path = NULL;
+  const uint8_t* input      = (const uint8_t*)argv[a++];
+  if (from_file) {
+    in_name = in_name ? in_name : input;
+    if (!in_fd) {
+      if (!strncmp((const char*)input, "file:", 5)) {
+        input_path = serd_file_uri_parse(input, NULL);
+        input      = input_path;
+      }
+      if (!input || !(in_fd = serd_fopen((const char*)input, "rb"))) {
+        return 1;
+      }
+    }
+  }
+
+  if (!input_syntax && !(input_syntax = guess_syntax((const char*)in_name))) {
+    input_syntax = SERD_TRIG;
+  }
+
+  if (!output_syntax) {
+    output_syntax =
+      ((input_syntax == SERD_TURTLE || input_syntax == SERD_NTRIPLES)
+         ? SERD_NTRIPLES
+         : SERD_NQUADS);
+  }
+
+  const SerdStyle output_style =
+    choose_style(input_syntax, output_syntax, ascii, bulk_write, full_uris);
+
+  SerdURI  base_uri = SERD_URI_NULL;
+  SerdNode base     = SERD_NODE_NULL;
+  if (a < argc) { // Base URI given on command line
+    base =
+      serd_node_new_uri_from_string((const uint8_t*)argv[a], NULL, &base_uri);
+  } else if (from_file && in_fd != stdin) { // Use input file URI
+    base = serd_node_new_file_uri(input, NULL, &base_uri, true);
+  }
+
+  FILE* const    out_fd = stdout;
+  SerdEnv* const env    = serd_env_new(&base);
+
+  SerdWriter* const writer = serd_writer_new(
+    output_syntax, output_style, env, &base_uri, serd_file_sink, out_fd);
+
+  SerdReader* const reader =
+    serd_reader_new(input_syntax,
+                    writer,
+                    NULL,
+                    (SerdBaseSink)serd_writer_set_base_uri,
+                    (SerdPrefixSink)serd_writer_set_prefix,
+                    (SerdStatementSink)serd_writer_write_statement,
+                    (SerdEndSink)serd_writer_end_anon);
+
+  serd_reader_set_strict(reader, !lax);
+  if (quiet) {
+    serd_reader_set_error_sink(reader, quiet_error_sink, NULL);
+    serd_writer_set_error_sink(writer, quiet_error_sink, NULL);
+  }
+
+  SerdNode root = serd_node_from_string(SERD_URI, root_uri);
+  serd_writer_set_root_uri(writer, &root);
+  serd_writer_chop_blank_prefix(writer, chop_prefix);
+  serd_reader_add_blank_prefix(reader, add_prefix);
+
+  SerdStatus st = SERD_SUCCESS;
+  if (!from_file) {
+    st = serd_reader_read_string(reader, input);
+  } else if (bulk_read) {
+    st = serd_reader_read_file_handle(reader, in_fd, in_name);
+  } else {
+    st = serd_reader_start_stream(reader, in_fd, in_name, false);
+    while (!st) {
+      st = serd_reader_read_chunk(reader);
+    }
+    serd_reader_end_stream(reader);
+  }
+
+  serd_reader_free(reader);
+  serd_writer_finish(writer);
+  serd_writer_free(writer);
+  serd_env_free(env);
+  serd_node_free(&base);
+  free(input_path);
+
+  if (from_file) {
+    fclose(in_fd);
+  }
+
+  if (fclose(out_fd)) {
+    perror("serdi: write error");
+    st = SERD_ERR_UNKNOWN;
+  }
+
+  return (st > SERD_FAILURE) ? 1 : 0;
 }
diff --git a/src/stack.h b/src/stack.h
index 01f69de6..053255d3 100644
--- a/src/stack.h
+++ b/src/stack.h
@@ -28,9 +28,9 @@
 
 /** A dynamic stack in memory. */
 typedef struct {
-	uint8_t* buf;       ///< Stack memory
-	size_t   buf_size;  ///< Allocated size of buf (>= size)
-	size_t   size;      ///< Conceptual size of stack in buf
+  uint8_t* buf;      ///< Stack memory
+  size_t   buf_size; ///< Allocated size of buf (>= size)
+  size_t   size;     ///< Conceptual size of stack in buf
 } SerdStack;
 
 /** An offset to start the stack at. Note 0 is reserved for NULL. */
@@ -39,79 +39,81 @@ typedef struct {
 static inline SerdStack
 serd_stack_new(size_t size)
 {
-	SerdStack stack;
-	stack.buf       = (uint8_t*)calloc(size, 1);
-	stack.buf_size  = size;
-	stack.size      = SERD_STACK_BOTTOM;
-	return stack;
+  SerdStack stack;
+  stack.buf      = (uint8_t*)calloc(size, 1);
+  stack.buf_size = size;
+  stack.size     = SERD_STACK_BOTTOM;
+  return stack;
 }
 
 static inline bool
 serd_stack_is_empty(SerdStack* stack)
 {
-	return stack->size <= SERD_STACK_BOTTOM;
+  return stack->size <= SERD_STACK_BOTTOM;
 }
 
 static inline void
 serd_stack_free(SerdStack* stack)
 {
-	free(stack->buf);
-	stack->buf      = NULL;
-	stack->buf_size = 0;
-	stack->size     = 0;
+  free(stack->buf);
+  stack->buf      = NULL;
+  stack->buf_size = 0;
+  stack->size     = 0;
 }
 
 static inline void*
 serd_stack_push(SerdStack* stack, size_t n_bytes)
 {
-	const size_t new_size = stack->size + n_bytes;
-	if (stack->buf_size < new_size) {
-		stack->buf_size += (stack->buf_size >> 1); // *= 1.5
-		stack->buf = (uint8_t*)realloc(stack->buf, stack->buf_size);
-	}
-	uint8_t* const ret = (stack->buf + stack->size);
-	stack->size = new_size;
-	return ret;
+  const size_t new_size = stack->size + n_bytes;
+  if (stack->buf_size < new_size) {
+    stack->buf_size += (stack->buf_size >> 1); // *= 1.5
+    stack->buf = (uint8_t*)realloc(stack->buf, stack->buf_size);
+  }
+
+  uint8_t* const ret = (stack->buf + stack->size);
+
+  stack->size = new_size;
+  return ret;
 }
 
 static inline void
 serd_stack_pop(SerdStack* stack, size_t n_bytes)
 {
-	assert(stack->size >= n_bytes);
-	stack->size -= n_bytes;
+  assert(stack->size >= n_bytes);
+  stack->size -= n_bytes;
 }
 
 static inline void*
 serd_stack_push_aligned(SerdStack* stack, size_t n_bytes, size_t align)
 {
-	// Push one byte to ensure space for a pad count
-	serd_stack_push(stack, 1);
+  // Push one byte to ensure space for a pad count
+  serd_stack_push(stack, 1);
 
-	// Push padding if necessary
-	const size_t pad = align - stack->size % align;
-	if (pad > 0) {
-		serd_stack_push(stack, pad);
-	}
+  // Push padding if necessary
+  const size_t pad = align - stack->size % align;
+  if (pad > 0) {
+    serd_stack_push(stack, pad);
+  }
 
-	// Set top of stack to pad count so we can properly pop later
-	assert(pad < UINT8_MAX);
-	stack->buf[stack->size - 1] = (uint8_t)pad;
+  // Set top of stack to pad count so we can properly pop later
+  assert(pad < UINT8_MAX);
+  stack->buf[stack->size - 1] = (uint8_t)pad;
 
-	// Push requested space at aligned location
-	return serd_stack_push(stack, n_bytes);
+  // Push requested space at aligned location
+  return serd_stack_push(stack, n_bytes);
 }
 
 static inline void
 serd_stack_pop_aligned(SerdStack* stack, size_t n_bytes)
 {
-	// Pop requested space down to aligned location
-	serd_stack_pop(stack, n_bytes);
+  // Pop requested space down to aligned location
+  serd_stack_pop(stack, n_bytes);
 
-	// Get amount of padding from top of stack
-	const uint8_t pad = stack->buf[stack->size - 1];
+  // Get amount of padding from top of stack
+  const uint8_t pad = stack->buf[stack->size - 1];
 
-	// Pop padding and pad count
-	serd_stack_pop(stack, pad + 1u);
+  // Pop padding and pad count
+  serd_stack_pop(stack, pad + 1u);
 }
 
-#endif  // SERD_STACK_H
+#endif // SERD_STACK_H
diff --git a/src/string.c b/src/string.c
index e1e5dbda..6946ba09 100644
--- a/src/string.c
+++ b/src/string.c
@@ -25,39 +25,50 @@
 void
 serd_free(void* ptr)
 {
-	free(ptr);
+  free(ptr);
 }
 
 const uint8_t*
 serd_strerror(SerdStatus status)
 {
-	switch (status) {
-	case SERD_SUCCESS:        return (const uint8_t*)"Success";
-	case SERD_FAILURE:        return (const uint8_t*)"Non-fatal failure";
-	case SERD_ERR_UNKNOWN:    return (const uint8_t*)"Unknown error";
-	case SERD_ERR_BAD_SYNTAX: return (const uint8_t*)"Invalid syntax";
-	case SERD_ERR_BAD_ARG:    return (const uint8_t*)"Invalid argument";
-	case SERD_ERR_NOT_FOUND:  return (const uint8_t*)"Not found";
-	case SERD_ERR_ID_CLASH:   return (const uint8_t*)"Blank node ID clash";
-	case SERD_ERR_BAD_CURIE:  return (const uint8_t*)"Invalid CURIE";
-	case SERD_ERR_INTERNAL:   return (const uint8_t*)"Internal error";
-	default:                  break;
-	}
-	return (const uint8_t*)"Unknown error";  // never reached
+  switch (status) {
+  case SERD_SUCCESS:
+    return (const uint8_t*)"Success";
+  case SERD_FAILURE:
+    return (const uint8_t*)"Non-fatal failure";
+  case SERD_ERR_UNKNOWN:
+    return (const uint8_t*)"Unknown error";
+  case SERD_ERR_BAD_SYNTAX:
+    return (const uint8_t*)"Invalid syntax";
+  case SERD_ERR_BAD_ARG:
+    return (const uint8_t*)"Invalid argument";
+  case SERD_ERR_NOT_FOUND:
+    return (const uint8_t*)"Not found";
+  case SERD_ERR_ID_CLASH:
+    return (const uint8_t*)"Blank node ID clash";
+  case SERD_ERR_BAD_CURIE:
+    return (const uint8_t*)"Invalid CURIE";
+  case SERD_ERR_INTERNAL:
+    return (const uint8_t*)"Internal error";
+  default:
+    break;
+  }
+  return (const uint8_t*)"Unknown error"; // never reached
 }
 
 static inline void
 serd_update_flags(const uint8_t c, SerdNodeFlags* const flags)
 {
-	switch (c) {
-	case '\r': case '\n':
-		*flags |= SERD_HAS_NEWLINE;
-		break;
-	case '"':
-		*flags |= SERD_HAS_QUOTE;
-	default:
-		break;
-	}
+  switch (c) {
+  case '\r':
+  case '\n':
+    *flags |= SERD_HAS_NEWLINE;
+    break;
+  case '"':
+    *flags |= SERD_HAS_QUOTE;
+  default:
+    break;
+  }
 }
 
 size_t
@@ -66,101 +77,103 @@ serd_substrlen(const uint8_t* const str,
                size_t* const        n_bytes,
                SerdNodeFlags* const flags)
 {
-	size_t        n_chars = 0;
-	size_t        i       = 0;
-	SerdNodeFlags f       = 0;
-	for (; i < len && str[i]; ++i) {
-		if ((str[i] & 0xC0) != 0x80) {  // Start of new character
-			++n_chars;
-			serd_update_flags(str[i], &f);
-		}
-	}
-	if (n_bytes) {
-		*n_bytes = i;
-	}
-	if (flags) {
-		*flags = f;
-	}
-	return n_chars;
+  size_t        n_chars = 0;
+  size_t        i       = 0;
+  SerdNodeFlags f       = 0;
+  for (; i < len && str[i]; ++i) {
+    if ((str[i] & 0xC0) != 0x80) { // Start of new character
+      ++n_chars;
+      serd_update_flags(str[i], &f);
+    }
+  }
+  if (n_bytes) {
+    *n_bytes = i;
+  }
+  if (flags) {
+    *flags = f;
+  }
+  return n_chars;
 }
 
 size_t
 serd_strlen(const uint8_t* str, size_t* n_bytes, SerdNodeFlags* flags)
 {
-	size_t        n_chars = 0;
-	size_t        i       = 0;
-	SerdNodeFlags f       = 0;
-	for (; str[i]; ++i) {
-		if ((str[i] & 0xC0) != 0x80) {  // Start of new character
-			++n_chars;
-			serd_update_flags(str[i], &f);
-		}
-	}
-	if (n_bytes) {
-		*n_bytes = i;
-	}
-	if (flags) {
-		*flags = f;
-	}
-	return n_chars;
+  size_t        n_chars = 0;
+  size_t        i       = 0;
+  SerdNodeFlags f       = 0;
+  for (; str[i]; ++i) {
+    if ((str[i] & 0xC0) != 0x80) { // Start of new character
+      ++n_chars;
+      serd_update_flags(str[i], &f);
+    }
+  }
+  if (n_bytes) {
+    *n_bytes = i;
+  }
+  if (flags) {
+    *flags = f;
+  }
+  return n_chars;
 }
 
 static inline double
 read_sign(const char** sptr)
 {
-	double sign = 1.0;
-	switch (**sptr) {
-	case '-':
-		sign = -1.0;
-		// fallthru
-	case '+':
-		++(*sptr);
-		// fallthru
-	default:
-		return sign;
-	}
+  double sign = 1.0;
+  switch (**sptr) {
+  case '-':
+    sign = -1.0;
+    // fallthru
+  case '+':
+    ++(*sptr);
+    // fallthru
+  default:
+    return sign;
+  }
 }
 
 double
 serd_strtod(const char* str, char** endptr)
 {
-	double result = 0.0;
-
-	// Point s at the first non-whitespace character
-	const char* s = str;
-	while (is_space(*s)) { ++s; }
-
-	// Read leading sign if necessary
-	const double sign = read_sign(&s);
-
-	// Parse integer part
-	for (; is_digit(*s); ++s) {
-		result = (result * 10.0) + (*s - '0');
-	}
-
-	// Parse fractional part
-	if (*s == '.') {
-		double denom = 10.0;
-		for (++s; is_digit(*s); ++s) {
-			result += (*s - '0') / denom;
-			denom *= 10.0;
-		}
-	}
-
-	// Parse exponent
-	if (*s == 'e' || *s == 'E') {
-		++s;
-		double expt      = 0.0;
-		double expt_sign = read_sign(&s);
-		for (; is_digit(*s); ++s) {
-			expt = (expt * 10.0) + (*s - '0');
-		}
-		result *= pow(10, expt * expt_sign);
-	}
-
-	if (endptr) {
-		*endptr = (char*)s;
-	}
-
-	return result * sign;
+  double result = 0.0;
+
+  // Point s at the first non-whitespace character
+  const char* s = str;
+  while (is_space(*s)) {
+    ++s;
+  }
+
+  // Read leading sign if necessary
+  const double sign = read_sign(&s);
+
+  // Parse integer part
+  for (; is_digit(*s); ++s) {
+    result = (result * 10.0) + (*s - '0');
+  }
+
+  // Parse fractional part
+  if (*s == '.') {
+    double denom = 10.0;
+    for (++s; is_digit(*s); ++s) {
+      result += (*s - '0') / denom;
+      denom *= 10.0;
+    }
+  }
+
+  // Parse exponent
+  if (*s == 'e' || *s == 'E') {
+    ++s;
+    double expt      = 0.0;
+    double expt_sign = read_sign(&s);
+    for (; is_digit(*s); ++s) {
+      expt = (expt * 10.0) + (*s - '0');
+    }
+    result *= pow(10, expt * expt_sign);
+  }
+
+  if (endptr) {
+    *endptr = (char*)s;
+  }
+
+  return result * sign;
 }
diff --git a/src/string_utils.h b/src/string_utils.h
index a80c3a27..b6b77c95 100644
--- a/src/string_utils.h
+++ b/src/string_utils.h
@@ -24,71 +24,76 @@
 #include <stdint.h>
 
 /** Unicode replacement character in UTF-8 */
-static const uint8_t replacement_char[] = { 0xEF, 0xBF, 0xBD };
+static const uint8_t replacement_char[] = {0xEF, 0xBF, 0xBD};
 
 /** Return true if `c` lies within [`min`...`max`] (inclusive) */
 static inline bool
 in_range(const int c, const int min, const int max)
 {
-	return (c >= min && c <= max);
+  return (c >= min && c <= max);
 }
 
 /** RFC2234: ALPHA ::= %x41-5A / %x61-7A  ; A-Z / a-z */
 static inline bool
 is_alpha(const int c)
 {
-	return in_range(c, 'A', 'Z') || in_range(c, 'a', 'z');
+  return in_range(c, 'A', 'Z') || in_range(c, 'a', 'z');
 }
 
 /** RFC2234: DIGIT ::= %x30-39  ; 0-9 */
 static inline bool
 is_digit(const int c)
 {
-	return in_range(c, '0', '9');
+  return in_range(c, '0', '9');
 }
 
 /* RFC2234: HEXDIG ::= DIGIT / "A" / "B" / "C" / "D" / "E" / "F" */
 static inline bool
 is_hexdig(const int c)
 {
-	return is_digit(c) || in_range(c, 'A', 'F');
+  return is_digit(c) || in_range(c, 'A', 'F');
 }
 
 /* Turtle / JSON / C: XDIGIT ::= DIGIT / A-F / a-f */
 static inline bool
 is_xdigit(const int c)
 {
-	return is_hexdig(c) || in_range(c, 'a', 'f');
+  return is_hexdig(c) || in_range(c, 'a', 'f');
 }
 
 static inline bool
 is_space(const char c)
 {
-	switch (c) {
-	case ' ': case '\f': case '\n': case '\r': case '\t': case '\v':
-		return true;
-	default:
-		return false;
-	}
+  switch (c) {
+  case ' ':
+  case '\f':
+  case '\n':
+  case '\r':
+  case '\t':
+  case '\v':
+    return true;
+  default:
+    return false;
+  }
 }
 
 static inline bool
 is_print(const int c)
 {
-	return c >= 0x20 && c <= 0x7E;
+  return c >= 0x20 && c <= 0x7E;
 }
 
 static inline bool
 is_base64(const uint8_t c)
 {
-	return is_alpha(c) || is_digit(c) || c == '+' || c == '/' || c == '=';
+  return is_alpha(c) || is_digit(c) || c == '+' || c == '/' || c == '=';
 }
 
 static inline bool
 is_windows_path(const uint8_t* path)
 {
-	return is_alpha(path[0]) && (path[1] == ':' || path[1] == '|')
-		&& (path[2] == '/' || path[2] == '\\');
+  return is_alpha(path[0]) && (path[1] == ':' || path[1] == '|') &&
+         (path[2] == '/' || path[2] == '\\');
 }
 
 size_t
@@ -100,65 +105,69 @@ serd_substrlen(const uint8_t* str,
 static inline char
 serd_to_upper(const char c)
 {
-	return (char)((c >= 'a' && c <= 'z') ? c - 32 : c);
+  return (char)((c >= 'a' && c <= 'z') ? c - 32 : c);
 }
 
 static inline int
 serd_strncasecmp(const char* s1, const char* s2, size_t n)
 {
-	for (; n > 0 && *s2; s1++, s2++, --n) {
-		if (serd_to_upper(*s1) != serd_to_upper(*s2)) {
-			return ((*(const uint8_t*)s1 < *(const uint8_t*)s2) ? -1 : +1);
-		}
-	}
-	return 0;
+  for (; n > 0 && *s2; s1++, s2++, --n) {
+    if (serd_to_upper(*s1) != serd_to_upper(*s2)) {
+      return ((*(const uint8_t*)s1 < *(const uint8_t*)s2) ? -1 : +1);
+    }
+  }
+
+  return 0;
 }
 
 static inline uint32_t
 utf8_num_bytes(const uint8_t c)
 {
-	if ((c & 0x80) == 0) {  // Starts with `0'
-		return 1;
-	}
+  if ((c & 0x80) == 0) { // Starts with `0'
+    return 1;
+  }
 
-	if ((c & 0xE0) == 0xC0) {  // Starts with `110'
-		return 2;
-	}
+  if ((c & 0xE0) == 0xC0) { // Starts with `110'
+    return 2;
+  }
 
-	if ((c & 0xF0) == 0xE0) {  // Starts with `1110'
-		return 3;
-	}
+  if ((c & 0xF0) == 0xE0) { // Starts with `1110'
+    return 3;
+  }
 
-	if ((c & 0xF8) == 0xF0) {  // Starts with `11110'
-		return 4;
-	}
+  if ((c & 0xF8) == 0xF0) { // Starts with `11110'
+    return 4;
+  }
 
-	return 0;
+  return 0;
 }
 
 /// Return the code point of a UTF-8 character with known length
 static inline uint32_t
 parse_counted_utf8_char(const uint8_t* utf8, size_t size)
 {
-	uint32_t c = utf8[0] & ((1u << (8 - size)) - 1);
-	for (size_t i = 1; i < size; ++i) {
-		const uint8_t in = utf8[i] & 0x3F;
-		c = (c << 6) | in;
-	}
-	return c;
+  uint32_t c = utf8[0] & ((1u << (8 - size)) - 1);
+  for (size_t i = 1; i < size; ++i) {
+    const uint8_t in = utf8[i] & 0x3F;
+    c                = (c << 6) | in;
+  }
+  return c;
 }
 
 /// Parse a UTF-8 character, set *size to the length, and return the code point
 static inline uint32_t
 parse_utf8_char(const uint8_t* utf8, size_t* size)
 {
-	switch (*size = utf8_num_bytes(utf8[0])) {
-	case 1: case 2: case 3: case 4:
-		return parse_counted_utf8_char(utf8, *size);
-	default:
-		*size = 0;
-		return 0;
-	}
+  switch (*size = utf8_num_bytes(utf8[0])) {
+  case 1:
+  case 2:
+  case 3:
+  case 4:
+    return parse_counted_utf8_char(utf8, *size);
+  default:
+    *size = 0;
+    return 0;
+  }
 }
 
-#endif  // SERD_STRING_UTILS_H
+#endif // SERD_STRING_UTILS_H
diff --git a/src/system.c b/src/system.c
index c6796da9..3f10b86b 100644
--- a/src/system.c
+++ b/src/system.c
@@ -22,11 +22,11 @@
 #include "serd_internal.h"
 
 #if defined(HAVE_POSIX_FADVISE) && defined(HAVE_FILENO)
-#   include <fcntl.h>
+#  include <fcntl.h>
 #endif
 
 #ifdef _WIN32
-#	include <malloc.h>
+#  include <malloc.h>
 #endif
 
 #include <errno.h>
@@ -37,47 +37,48 @@
 FILE*
 serd_fopen(const char* path, const char* mode)
 {
-	FILE* fd = fopen(path, mode);
-	if (!fd) {
-		fprintf(stderr, "error: failed to open file %s (%s)\n",
-		        path, strerror(errno));
-		return NULL;
-	}
+  FILE* fd = fopen(path, mode);
+  if (!fd) {
+    fprintf(
+      stderr, "error: failed to open file %s (%s)\n", path, strerror(errno));
+    return NULL;
+  }
+
 #if defined(HAVE_POSIX_FADVISE) && defined(HAVE_FILENO)
-	posix_fadvise(fileno(fd), 0, 0, POSIX_FADV_SEQUENTIAL);
+  posix_fadvise(fileno(fd), 0, 0, POSIX_FADV_SEQUENTIAL);
 #endif
-	return fd;
+  return fd;
 }
 
 void*
 serd_malloc_aligned(const size_t alignment, const size_t size)
 {
 #if defined(_WIN32)
-	return _aligned_malloc(size, alignment);
+  return _aligned_malloc(size, alignment);
 #elif __STDC_VERSION__ >= 201112L && defined(HAVE_ALIGNED_ALLOC)
-	return aligned_alloc(alignment, size);
+  return aligned_alloc(alignment, size);
 #elif defined(HAVE_POSIX_MEMALIGN)
-	void*     ptr = NULL;
-	const int ret = posix_memalign(&ptr, alignment, size);
-	return ret ? NULL : ptr;
+  void*     ptr = NULL;
+  const int ret = posix_memalign(&ptr, alignment, size);
+  return ret ? NULL : ptr;
 #else
-	(void)alignment;
-	return malloc(size);
+  (void)alignment;
+  return malloc(size);
 #endif
 }
 
 void*
 serd_allocate_buffer(const size_t size)
 {
-	return serd_malloc_aligned(SERD_PAGE_SIZE, size);
+  return serd_malloc_aligned(SERD_PAGE_SIZE, size);
 }
 
 void
 serd_free_aligned(void* const ptr)
 {
 #ifdef _WIN32
-	_aligned_free(ptr);
+  _aligned_free(ptr);
 #else
-	free(ptr);
+  free(ptr);
 #endif
 }
diff --git a/src/system.h b/src/system.h
index 57203820..fe2713b5 100644
--- a/src/system.h
+++ b/src/system.h
@@ -22,15 +22,19 @@
 #include <stdio.h>
 
 /// Open a file configured for fast sequential reading
-FILE* serd_fopen(const char* path, const char* mode);
+FILE*
+serd_fopen(const char* path, const char* mode);
 
 /// Allocate a buffer aligned to `alignment` bytes
-SERD_MALLOC_FUNC void* serd_malloc_aligned(size_t alignment, size_t size);
+SERD_MALLOC_FUNC void*
+serd_malloc_aligned(size_t alignment, size_t size);
 
 /// Allocate an aligned buffer for I/O
-SERD_MALLOC_FUNC void* serd_allocate_buffer(size_t size);
+SERD_MALLOC_FUNC void*
+serd_allocate_buffer(size_t size);
 
 /// Free a buffer allocated with an aligned allocation function
-void serd_free_aligned(void* ptr);
+void
+serd_free_aligned(void* ptr);
 
 #endif // SERD_SYSTEM_H
diff --git a/src/uri.c b/src/uri.c
index 718f24ee..6b387459 100644
--- a/src/uri.c
+++ b/src/uri.c
@@ -28,198 +28,214 @@
 const uint8_t*
 serd_uri_to_path(const uint8_t* uri)
 {
-	const uint8_t* path = uri;
-	if (!is_windows_path(uri) && serd_uri_string_has_scheme(uri)) {
-		if (strncmp((const char*)uri, "file:", 5)) {
-			fprintf(stderr, "Non-file URI `%s'\n", uri);
-			return NULL;
-		}
-
-		if (!strncmp((const char*)uri, "file://localhost/", 17)) {
-			path = uri + 16;
-		} else if (!strncmp((const char*)uri, "file://", 7)) {
-			path = uri + 7;
-		} else {
-			fprintf(stderr, "Invalid file URI `%s'\n", uri);
-			return NULL;
-		}
-
-		if (is_windows_path(path + 1)) {
-			++path;  // Special case for terrible Windows file URIs
-		}
-	}
-	return path;
+  const uint8_t* path = uri;
+  if (!is_windows_path(uri) && serd_uri_string_has_scheme(uri)) {
+    if (strncmp((const char*)uri, "file:", 5)) {
+      fprintf(stderr, "Non-file URI `%s'\n", uri);
+      return NULL;
+    }
+
+    if (!strncmp((const char*)uri, "file://localhost/", 17)) {
+      path = uri + 16;
+    } else if (!strncmp((const char*)uri, "file://", 7)) {
+      path = uri + 7;
+    } else {
+      fprintf(stderr, "Invalid file URI `%s'\n", uri);
+      return NULL;
+    }
+
+    if (is_windows_path(path + 1)) {
+      ++path; // Special case for terrible Windows file URIs
+    }
+  }
+  return path;
 }
 
 uint8_t*
 serd_file_uri_parse(const uint8_t* uri, uint8_t** hostname)
 {
-	const uint8_t* path = uri;
-	if (hostname) {
-		*hostname = NULL;
-	}
-	if (!strncmp((const char*)uri, "file://", 7)) {
-		const uint8_t* auth = uri + 7;
-		if (*auth == '/') {  // No hostname
-			path = auth;
-		} else {  // Has hostname
-			if (!(path = (const uint8_t*)strchr((const char*)auth, '/'))) {
-				return NULL;
-			}
-			if (hostname) {
-				*hostname = (uint8_t*)calloc((size_t)(path - auth + 1), 1);
-				memcpy(*hostname, auth, (size_t)(path - auth));
-			}
-		}
-	}
-
-	if (is_windows_path(path + 1)) {
-		++path;
-	}
-
-	SerdChunk chunk = { NULL, 0 };
-	for (const uint8_t* s = path; *s; ++s) {
-		if (*s == '%') {
-			if (*(s + 1) == '%') {
-				serd_chunk_sink("%", 1, &chunk);
-				++s;
-			} else if (is_hexdig(*(s + 1)) && is_hexdig(*(s + 2))) {
-				const uint8_t code[3] = {*(s + 1), *(s + 2), 0};
-				const uint8_t c = (uint8_t)strtoul((const char*)code, NULL, 16);
-				serd_chunk_sink(&c, 1, &chunk);
-				s += 2;
-			} else {
-				s += 2;  // Junk escape, ignore
-			}
-		} else {
-			serd_chunk_sink(s, 1, &chunk);
-		}
-	}
-	return serd_chunk_sink_finish(&chunk);
+  const uint8_t* path = uri;
+  if (hostname) {
+    *hostname = NULL;
+  }
+  if (!strncmp((const char*)uri, "file://", 7)) {
+    const uint8_t* auth = uri + 7;
+    if (*auth == '/') { // No hostname
+      path = auth;
+    } else { // Has hostname
+      if (!(path = (const uint8_t*)strchr((const char*)auth, '/'))) {
+        return NULL;
+      }
+
+      if (hostname) {
+        *hostname = (uint8_t*)calloc((size_t)(path - auth + 1), 1);
+        memcpy(*hostname, auth, (size_t)(path - auth));
+      }
+    }
+  }
+
+  if (is_windows_path(path + 1)) {
+    ++path;
+  }
+
+  SerdChunk chunk = {NULL, 0};
+  for (const uint8_t* s = path; *s; ++s) {
+    if (*s == '%') {
+      if (*(s + 1) == '%') {
+        serd_chunk_sink("%", 1, &chunk);
+        ++s;
+      } else if (is_hexdig(*(s + 1)) && is_hexdig(*(s + 2))) {
+        const uint8_t code[3] = {*(s + 1), *(s + 2), 0};
+        const uint8_t c       = (uint8_t)strtoul((const char*)code, NULL, 16);
+        serd_chunk_sink(&c, 1, &chunk);
+        s += 2;
+      } else {
+        s += 2; // Junk escape, ignore
+      }
+    } else {
+      serd_chunk_sink(s, 1, &chunk);
+    }
+  }
+
+  return serd_chunk_sink_finish(&chunk);
 }
 
 bool
 serd_uri_string_has_scheme(const uint8_t* utf8)
 {
-	// RFC3986: scheme ::= ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
-	if (!utf8 || !is_alpha(utf8[0])) {
-		return false;  // Invalid scheme initial character, URI is relative
-	}
-
-	for (uint8_t c = 0; (c = *++utf8) != '\0';) {
-		if (!is_uri_scheme_char(c)) {
-			return false;
-		}
-
-		if (c == ':') {
-			return true;  // End of scheme
-		}
-	}
-
-	return false;
+  // RFC3986: scheme ::= ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
+  if (!utf8 || !is_alpha(utf8[0])) {
+    return false; // Invalid scheme initial character, URI is relative
+  }
+
+  for (uint8_t c = 0; (c = *++utf8) != '\0';) {
+    if (!is_uri_scheme_char(c)) {
+      return false;
+    }
+
+    if (c == ':') {
+      return true; // End of scheme
+    }
+  }
+
+  return false;
 }
 
 SerdStatus
 serd_uri_parse(const uint8_t* utf8, SerdURI* out)
 {
-	*out = SERD_URI_NULL;
-
-	const uint8_t* ptr = utf8;
-
-	/* See http://tools.ietf.org/html/rfc3986#section-3
-	   URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
-	*/
-
-	/* S3.1: scheme ::= ALPHA *( ALPHA / DIGIT / "+" / "-" / "." ) */
-	if (is_alpha(*ptr)) {
-		for (uint8_t c = *++ptr; true; c = *++ptr) {
-			switch (c) {
-			case '\0': case '/': case '?': case '#':
-				ptr = utf8;
-				goto path;  // Relative URI (starts with path by definition)
-			case ':':
-				out->scheme.buf = utf8;
-				out->scheme.len = (size_t)((ptr++) - utf8);
-				goto maybe_authority;  // URI with scheme
-			case '+': case '-': case '.':
-				continue;
-			default:
-				if (is_alpha(c) || is_digit(c)) {
-					continue;
-				}
-			}
-		}
-	}
-
-	/* S3.2: The authority component is preceded by a double slash ("//")
-	   and is terminated by the next slash ("/"), question mark ("?"),
-	   or number sign ("#") character, or by the end of the URI.
-	*/
+  *out = SERD_URI_NULL;
+
+  const uint8_t* ptr = utf8;
+
+  /* See http://tools.ietf.org/html/rfc3986#section-3
+     URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
+  */
+
+  /* S3.1: scheme ::= ALPHA *( ALPHA / DIGIT / "+" / "-" / "." ) */
+  if (is_alpha(*ptr)) {
+    for (uint8_t c = *++ptr; true; c = *++ptr) {
+      switch (c) {
+      case '\0':
+      case '/':
+      case '?':
+      case '#':
+        ptr = utf8;
+        goto path; // Relative URI (starts with path by definition)
+      case ':':
+        out->scheme.buf = utf8;
+        out->scheme.len = (size_t)((ptr++) - utf8);
+        goto maybe_authority; // URI with scheme
+      case '+':
+      case '-':
+      case '.':
+        continue;
+      default:
+        if (is_alpha(c) || is_digit(c)) {
+          continue;
+        }
+      }
+    }
+  }
+
+  /* S3.2: The authority component is preceded by a double slash ("//")
+     and is terminated by the next slash ("/"), question mark ("?"),
+     or number sign ("#") character, or by the end of the URI.
+  */
 maybe_authority:
-	if (*ptr == '/' && *(ptr + 1) == '/') {
-		ptr += 2;
-		out->authority.buf = ptr;
-		for (uint8_t c = 0; (c = *ptr) != '\0'; ++ptr) {
-			switch (c) {
-			case '/': goto path;
-			case '?': goto query;
-			case '#': goto fragment;
-			default:
-				++out->authority.len;
-			}
-		}
-	}
-
-	/* RFC3986 S3.3: The path is terminated by the first question mark ("?")
-	   or number sign ("#") character, or by the end of the URI.
-	*/
+  if (*ptr == '/' && *(ptr + 1) == '/') {
+    ptr += 2;
+    out->authority.buf = ptr;
+    for (uint8_t c = 0; (c = *ptr) != '\0'; ++ptr) {
+      switch (c) {
+      case '/':
+        goto path;
+      case '?':
+        goto query;
+      case '#':
+        goto fragment;
+      default:
+        ++out->authority.len;
+      }
+    }
+  }
+
+  /* RFC3986 S3.3: The path is terminated by the first question mark ("?")
+     or number sign ("#") character, or by the end of the URI.
+  */
 path:
-	switch (*ptr) {
-	case '?':  goto query;
-	case '#':  goto fragment;
-	case '\0': goto end;
-	default:  break;
-	}
-	out->path.buf = ptr;
-	out->path.len = 0;
-	for (uint8_t c = 0; (c = *ptr) != '\0'; ++ptr) {
-		switch (c) {
-		case '?': goto query;
-		case '#': goto fragment;
-		default:
-			++out->path.len;
-		}
-	}
-
-	/* RFC3986 S3.4: The query component is indicated by the first question
-	   mark ("?") character and terminated by a number sign ("#") character
-	   or by the end of the URI.
-	*/
+  switch (*ptr) {
+  case '?':
+    goto query;
+  case '#':
+    goto fragment;
+  case '\0':
+    goto end;
+  default:
+    break;
+  }
+  out->path.buf = ptr;
+  out->path.len = 0;
+  for (uint8_t c = 0; (c = *ptr) != '\0'; ++ptr) {
+    switch (c) {
+    case '?':
+      goto query;
+    case '#':
+      goto fragment;
+    default:
+      ++out->path.len;
+    }
+  }
+
+  /* RFC3986 S3.4: The query component is indicated by the first question
+     mark ("?") character and terminated by a number sign ("#") character
+     or by the end of the URI.
+  */
 query:
-	if (*ptr == '?') {
-		out->query.buf = ++ptr;
-		for (uint8_t c = 0; (c = *ptr) != '\0'; ++ptr) {
-			if (c == '#') {
-				goto fragment;
-			}
-			++out->query.len;
-		}
-	}
-
-	/* RFC3986 S3.5: A fragment identifier component is indicated by the
-	   presence of a number sign ("#") character and terminated by the end
-	   of the URI.
-	*/
+  if (*ptr == '?') {
+    out->query.buf = ++ptr;
+    for (uint8_t c = 0; (c = *ptr) != '\0'; ++ptr) {
+      if (c == '#') {
+        goto fragment;
+      }
+      ++out->query.len;
+    }
+  }
+
+  /* RFC3986 S3.5: A fragment identifier component is indicated by the
+     presence of a number sign ("#") character and terminated by the end
+     of the URI.
+  */
 fragment:
-	if (*ptr == '#') {
-		out->fragment.buf = ptr;
-		while (*ptr++ != '\0') {
-			++out->fragment.len;
-		}
-	}
+  if (*ptr == '#') {
+    out->fragment.buf = ptr;
+    while (*ptr++ != '\0') {
+      ++out->fragment.len;
+    }
+  }
 
 end:
-	return SERD_SUCCESS;
+  return SERD_SUCCESS;
 }
 
 /**
@@ -231,149 +247,153 @@ end:
 static const uint8_t*
 remove_dot_segments(const uint8_t* path, size_t len, size_t* up)
 {
-	const uint8_t*       begin = path;
-	const uint8_t* const end   = path + len;
-
-	*up = 0;
-	while (begin < end) {
-		switch (begin[0]) {
-		case '.':
-			switch (begin[1]) {
-			case '/':
-				begin += 2;  // Chop leading "./"
-				break;
-			case '.':
-				switch (begin[2]) {
-				case '\0':
-					++*up;
-					begin += 2;  // Chop input ".."
-					break;
-				case '/':
-					++*up;
-					begin += 3;  // Chop leading "../"
-					break;
-				default:
-					return begin;
-				}
-				break;
-			case '\0':
-				++begin;  // Chop input "."
-                // fallthru
-			default:
-				return begin;
-			}
-			break;
-		case '/':
-			switch (begin[1]) {
-			case '.':
-				switch (begin[2]) {
-				case '/':
-					begin += 2;  // Leading "/./" => "/"
-					break;
-				case '.':
-					switch (begin[3]) {
-					case '/':
-						++*up;
-						begin += 3;  // Leading "/../" => "/"
-					}
-					break;
-				default:
-					return begin;
-				}
-			}  // else fall through
-		default:
-			return begin;  // Finished chopping dot components
-		}
-	}
-
-	return begin;
+  const uint8_t*       begin = path;
+  const uint8_t* const end   = path + len;
+
+  *up = 0;
+  while (begin < end) {
+    switch (begin[0]) {
+    case '.':
+      switch (begin[1]) {
+      case '/':
+        begin += 2; // Chop leading "./"
+        break;
+      case '.':
+        switch (begin[2]) {
+        case '\0':
+          ++*up;
+          begin += 2; // Chop input ".."
+          break;
+        case '/':
+          ++*up;
+          begin += 3; // Chop leading "../"
+          break;
+        default:
+          return begin;
+        }
+        break;
+      case '\0':
+        return ++begin; // Chop input "."
+      default:
+        return begin;
+      }
+      break;
+
+    case '/':
+      switch (begin[1]) {
+      case '.':
+        switch (begin[2]) {
+        case '/':
+          begin += 2; // Leading "/./" => "/"
+          break;
+        case '.':
+          switch (begin[3]) {
+          case '/':
+            ++*up;
+            begin += 3; // Leading "/../" => "/"
+          }
+          break;
+        default:
+          return begin;
+        }
+      }
+      return begin;
+
+    default:
+      return begin; // Finished chopping dot components
+    }
+  }
+
+  return begin;
 }
 
 /// Merge `base` and `path` in-place
 static void
 merge(SerdChunk* base, SerdChunk* path)
 {
-	size_t         up    = 0;
-	const uint8_t* begin = remove_dot_segments(path->buf, path->len, &up);
-	const uint8_t* end   = path->buf + path->len;
-
-	if (base->len) {
-		// Find the up'th last slash
-		const uint8_t* base_last = (base->buf + base->len - 1);
-		++up;
-		do {
-			if (*base_last == '/') {
-				--up;
-			}
-		} while (up > 0 && (--base_last > base->buf));
-
-		// Set path prefix
-		base->len = (size_t)(base_last - base->buf + 1);
-	}
-
-	// Set path suffix
-	path->buf = begin;
-	path->len = (size_t)(end - begin);
+  size_t         up    = 0;
+  const uint8_t* begin = remove_dot_segments(path->buf, path->len, &up);
+  const uint8_t* end   = path->buf + path->len;
+
+  if (base->len) {
+    // Find the up'th last slash
+    const uint8_t* base_last = (base->buf + base->len - 1);
+    ++up;
+    do {
+      if (*base_last == '/') {
+        --up;
+      }
+    } while (up > 0 && (--base_last > base->buf));
+
+    // Set path prefix
+    base->len = (size_t)(base_last - base->buf + 1);
+  }
+
+  // Set path suffix
+  path->buf = begin;
+  path->len = (size_t)(end - begin);
 }
 
 /// See http://tools.ietf.org/html/rfc3986#section-5.2.2
 void
 serd_uri_resolve(const SerdURI* r, const SerdURI* base, SerdURI* t)
 {
-	if (!base->scheme.len) {
-		*t = *r;  // Don't resolve against non-absolute URIs
-		return;
-	}
-
-	t->path_base.buf = NULL;
-	t->path_base.len = 0;
-	if (r->scheme.len) {
-		*t = *r;
-	} else {
-		if (r->authority.len) {
-			t->authority = r->authority;
-			t->path      = r->path;
-			t->query     = r->query;
-		} else {
-			t->path = r->path;
-			if (!r->path.len) {
-				t->path_base = base->path;
-				if (r->query.len) {
-					t->query = r->query;
-				} else {
-					t->query = base->query;
-				}
-			} else {
-				if (r->path.buf[0] != '/') {
-					t->path_base = base->path;
-				}
-				merge(&t->path_base, &t->path);
-				t->query = r->query;
-			}
-			t->authority = base->authority;
-		}
-		t->scheme   = base->scheme;
-		t->fragment = r->fragment;
-	}
+  if (!base->scheme.len) {
+    *t = *r; // Don't resolve against non-absolute URIs
+    return;
+  }
+
+  t->path_base.buf = NULL;
+  t->path_base.len = 0;
+  if (r->scheme.len) {
+    *t = *r;
+  } else {
+    if (r->authority.len) {
+      t->authority = r->authority;
+      t->path      = r->path;
+      t->query     = r->query;
+    } else {
+      t->path = r->path;
+      if (!r->path.len) {
+        t->path_base = base->path;
+        if (r->query.len) {
+          t->query = r->query;
+        } else {
+          t->query = base->query;
+        }
+      } else {
+        if (r->path.buf[0] != '/') {
+          t->path_base = base->path;
+        }
+        merge(&t->path_base, &t->path);
+        t->query = r->query;
+      }
+      t->authority = base->authority;
+    }
+    t->scheme   = base->scheme;
+    t->fragment = r->fragment;
+  }
 }
 
 /** Write the path of `uri` starting at index `i` */
 static size_t
 write_path_tail(SerdSink sink, void* stream, const SerdURI* uri, size_t i)
 {
-	size_t len = 0;
-	if (i < uri->path_base.len) {
-		len += sink(uri->path_base.buf + i, uri->path_base.len - i, stream);
-	}
-	if (uri->path.buf) {
-		if (i < uri->path_base.len) {
-			len += sink(uri->path.buf, uri->path.len, stream);
-		} else {
-			const size_t j = (i - uri->path_base.len);
-			len += sink(uri->path.buf + j, uri->path.len - j, stream);
-		}
-	}
-	return len;
+  size_t len = 0;
+  if (i < uri->path_base.len) {
+    len += sink(uri->path_base.buf + i, uri->path_base.len - i, stream);
+  }
+
+  if (uri->path.buf) {
+    if (i < uri->path_base.len) {
+      len += sink(uri->path.buf, uri->path.len, stream);
+    } else {
+      const size_t j = (i - uri->path_base.len);
+      len += sink(uri->path.buf + j, uri->path.len - j, stream);
+    }
+  }
+
+  return len;
 }
 
 /** Write the path of `uri` relative to the path of `base`. */
@@ -383,51 +403,51 @@ write_rel_path(SerdSink       sink,
                const SerdURI* uri,
                const SerdURI* base)
 {
-	const size_t path_len = uri_path_len(uri);
-	const size_t base_len = uri_path_len(base);
-	const size_t min_len  = (path_len < base_len) ? path_len : base_len;
-
-	// Find the last separator common to both paths
-	size_t last_shared_sep = 0;
-	size_t i               = 0;
-	for (; i < min_len && uri_path_at(uri, i) == uri_path_at(base, i); ++i) {
-		if (uri_path_at(uri, i) == '/') {
-			last_shared_sep = i;
-		}
-	}
-
-	if (i == path_len && i == base_len) {  // Paths are identical
-		return 0;
-	}
-
-	// Find the number of up references ("..") required
-	size_t up = 0;
-	for (size_t s = last_shared_sep + 1; s < base_len; ++s) {
-		if (uri_path_at(base, s) == '/') {
-			++up;
-		}
-	}
-
-	// Write up references
-	size_t len = 0;
-	for (size_t u = 0; u < up; ++u) {
-		len += sink("../", 3, stream);
-	}
-
-	if (last_shared_sep == 0 && up == 0) {
-		len += sink("/", 1, stream);
-	}
-
-	// Write suffix
-	return len + write_path_tail(sink, stream, uri, last_shared_sep + 1);
+  const size_t path_len = uri_path_len(uri);
+  const size_t base_len = uri_path_len(base);
+  const size_t min_len  = (path_len < base_len) ? path_len : base_len;
+
+  // Find the last separator common to both paths
+  size_t last_shared_sep = 0;
+  size_t i               = 0;
+  for (; i < min_len && uri_path_at(uri, i) == uri_path_at(base, i); ++i) {
+    if (uri_path_at(uri, i) == '/') {
+      last_shared_sep = i;
+    }
+  }
+
+  if (i == path_len && i == base_len) { // Paths are identical
+    return 0;
+  }
+
+  // Find the number of up references ("..") required
+  size_t up = 0;
+  for (size_t s = last_shared_sep + 1; s < base_len; ++s) {
+    if (uri_path_at(base, s) == '/') {
+      ++up;
+    }
+  }
+
+  // Write up references
+  size_t len = 0;
+  for (size_t u = 0; u < up; ++u) {
+    len += sink("../", 3, stream);
+  }
+
+  if (last_shared_sep == 0 && up == 0) {
+    len += sink("/", 1, stream);
+  }
+
+  // Write suffix
+  return len + write_path_tail(sink, stream, uri, last_shared_sep + 1);
 }
 
 static uint8_t
 serd_uri_path_starts_without_slash(const SerdURI* uri)
 {
-	return ((uri->path_base.len || uri->path.len) &&
-	        ((!uri->path_base.len || uri->path_base.buf[0] != '/') &&
-	         (!uri->path.len || uri->path.buf[0] != '/')));
+  return ((uri->path_base.len || uri->path.len) &&
+          ((!uri->path_base.len || uri->path_base.buf[0] != '/') &&
+           (!uri->path.len || uri->path.buf[0] != '/')));
 }
 
 /// See http://tools.ietf.org/html/rfc3986#section-5.3
@@ -438,45 +458,49 @@ serd_uri_serialise_relative(const SerdURI* uri,
                             SerdSink       sink,
                             void*          stream)
 {
-	size_t     len = 0;
-	const bool relative =
-		root ? uri_is_under(uri, root) : uri_is_related(uri, base);
-
-	if (relative) {
-		len = write_rel_path(sink, stream, uri, base);
-	}
-	if (!relative || (!len && base->query.buf)) {
-		if (uri->scheme.buf) {
-			len += sink(uri->scheme.buf, uri->scheme.len, stream);
-			len += sink(":", 1, stream);
-		}
-		if (uri->authority.buf) {
-			len += sink("//", 2, stream);
-			len += sink(uri->authority.buf, uri->authority.len, stream);
-			if (uri->authority.len > 0 &&
-			    uri->authority.buf[uri->authority.len - 1] != '/' &&
-			    serd_uri_path_starts_without_slash(uri)) {
-				// Special case: ensure path begins with a slash
-				// https://tools.ietf.org/html/rfc3986#section-3.2
-				len += sink("/", 1, stream);
-			}
-		}
-		len += write_path_tail(sink, stream, uri, 0);
-	}
-	if (uri->query.buf) {
-		len += sink("?", 1, stream);
-		len += sink(uri->query.buf, uri->query.len, stream);
-	}
-	if (uri->fragment.buf) {
-		// Note uri->fragment.buf includes the leading `#'
-		len += sink(uri->fragment.buf, uri->fragment.len, stream);
-	}
-	return len;
+  size_t     len = 0;
+  const bool relative =
+    root ? uri_is_under(uri, root) : uri_is_related(uri, base);
+
+  if (relative) {
+    len = write_rel_path(sink, stream, uri, base);
+  }
+
+  if (!relative || (!len && base->query.buf)) {
+    if (uri->scheme.buf) {
+      len += sink(uri->scheme.buf, uri->scheme.len, stream);
+      len += sink(":", 1, stream);
+    }
+    if (uri->authority.buf) {
+      len += sink("//", 2, stream);
+      len += sink(uri->authority.buf, uri->authority.len, stream);
+      if (uri->authority.len > 0 &&
+          uri->authority.buf[uri->authority.len - 1] != '/' &&
+          serd_uri_path_starts_without_slash(uri)) {
+        // Special case: ensure path begins with a slash
+        // https://tools.ietf.org/html/rfc3986#section-3.2
+        len += sink("/", 1, stream);
+      }
+    }
+    len += write_path_tail(sink, stream, uri, 0);
+  }
+
+  if (uri->query.buf) {
+    len += sink("?", 1, stream);
+    len += sink(uri->query.buf, uri->query.len, stream);
+  }
+
+  if (uri->fragment.buf) {
+    // Note uri->fragment.buf includes the leading `#'
+    len += sink(uri->fragment.buf, uri->fragment.len, stream);
+  }
+
+  return len;
 }
 
 /// See http://tools.ietf.org/html/rfc3986#section-5.3
 size_t
 serd_uri_serialise(const SerdURI* uri, SerdSink sink, void* stream)
 {
-	return serd_uri_serialise_relative(uri, NULL, NULL, sink, stream);
+  return serd_uri_serialise_relative(uri, NULL, NULL, sink, stream);
 }
diff --git a/src/uri_utils.h b/src/uri_utils.h
index d7c90b12..2ba9823c 100644
--- a/src/uri_utils.h
+++ b/src/uri_utils.h
@@ -28,21 +28,21 @@
 static inline bool
 chunk_equals(const SerdChunk* a, const SerdChunk* b)
 {
-	return a->len == b->len
-		&& !strncmp((const char*)a->buf, (const char*)b->buf, a->len);
+  return a->len == b->len &&
+         !strncmp((const char*)a->buf, (const char*)b->buf, a->len);
 }
 
 static inline size_t
 uri_path_len(const SerdURI* uri)
 {
-	return uri->path_base.len + uri->path.len;
+  return uri->path_base.len + uri->path.len;
 }
 
 static inline uint8_t
 uri_path_at(const SerdURI* uri, size_t i)
 {
-	return (i < uri->path_base.len) ? uri->path_base.buf[i]
-	                                : uri->path.buf[i - uri->path_base.len];
+  return (i < uri->path_base.len) ? uri->path_base.buf[i]
+                                  : uri->path.buf[i - uri->path_base.len];
 }
 
 /**
@@ -52,56 +52,59 @@ uri_path_at(const SerdURI* uri, size_t i)
 static inline SERD_PURE_FUNC size_t
 uri_rooted_index(const SerdURI* uri, const SerdURI* root)
 {
-	if (!root || !root->scheme.len ||
-	    !chunk_equals(&root->scheme, &uri->scheme) ||
-	    !chunk_equals(&root->authority, &uri->authority)) {
-		return 0;
-	}
-
-	bool         differ          = false;
-	const size_t path_len        = uri_path_len(uri);
-	const size_t root_len        = uri_path_len(root);
-	size_t       last_root_slash = 0;
-	for (size_t i = 0; i < path_len && i < root_len; ++i) {
-		const uint8_t u = uri_path_at(uri, i);
-		const uint8_t r = uri_path_at(root, i);
-
-		differ = differ || u != r;
-		if (r == '/') {
-			last_root_slash = i;
-			if (differ) {
-				return 0;
-			}
-		}
-	}
-
-	return last_root_slash + 1;
+  if (!root || !root->scheme.len ||
+      !chunk_equals(&root->scheme, &uri->scheme) ||
+      !chunk_equals(&root->authority, &uri->authority)) {
+    return 0;
+  }
+
+  bool         differ          = false;
+  const size_t path_len        = uri_path_len(uri);
+  const size_t root_len        = uri_path_len(root);
+  size_t       last_root_slash = 0;
+  for (size_t i = 0; i < path_len && i < root_len; ++i) {
+    const uint8_t u = uri_path_at(uri, i);
+    const uint8_t r = uri_path_at(root, i);
+
+    differ = differ || u != r;
+    if (r == '/') {
+      last_root_slash = i;
+      if (differ) {
+        return 0;
+      }
+    }
+  }
+
+  return last_root_slash + 1;
 }
 
 /** Return true iff `uri` shares path components with `root` */
 static inline SERD_PURE_FUNC bool
 uri_is_related(const SerdURI* uri, const SerdURI* root)
 {
-	return uri_rooted_index(uri, root) > 0;
+  return uri_rooted_index(uri, root) > 0;
 }
 
 /** Return true iff `uri` is within the base of `root` */
 static inline SERD_PURE_FUNC bool
 uri_is_under(const SerdURI* uri, const SerdURI* root)
 {
-	const size_t index = uri_rooted_index(uri, root);
-	return index > 0 && uri->path.len > index;
+  const size_t index = uri_rooted_index(uri, root);
+  return index > 0 && uri->path.len > index;
 }
 
 static inline bool
 is_uri_scheme_char(const int c)
 {
-	switch (c) {
-	case ':': case '+': case '-': case '.':
-		return true;
-	default:
-		return is_alpha(c) || is_digit(c);
-	}
+  switch (c) {
+  case ':':
+  case '+':
+  case '-':
+  case '.':
+    return true;
+  default:
+    return is_alpha(c) || is_digit(c);
+  }
 }
 
-#endif  // SERD_URI_UTILS_H
+#endif // SERD_URI_UTILS_H
diff --git a/src/writer.c b/src/writer.c
index 8c0d4b3f..386276fe 100644
--- a/src/writer.c
+++ b/src/writer.c
@@ -31,95 +31,88 @@
 #include <string.h>
 
 typedef enum {
-	FIELD_NONE,
-	FIELD_SUBJECT,
-	FIELD_PREDICATE,
-	FIELD_OBJECT,
-	FIELD_GRAPH
+  FIELD_NONE,
+  FIELD_SUBJECT,
+  FIELD_PREDICATE,
+  FIELD_OBJECT,
+  FIELD_GRAPH
 } Field;
 
 typedef struct {
-	SerdNode graph;
-	SerdNode subject;
-	SerdNode predicate;
+  SerdNode graph;
+  SerdNode subject;
+  SerdNode predicate;
 } WriteContext;
 
-static const WriteContext WRITE_CONTEXT_NULL = {
-	{ 0, 0, 0, 0, SERD_NOTHING },
-	{ 0, 0, 0, 0, SERD_NOTHING },
-	{ 0, 0, 0, 0, SERD_NOTHING }
-};
+static const WriteContext WRITE_CONTEXT_NULL = {{0, 0, 0, 0, SERD_NOTHING},
+                                                {0, 0, 0, 0, SERD_NOTHING},
+                                                {0, 0, 0, 0, SERD_NOTHING}};
 
 typedef enum {
-	SEP_NONE,
-	SEP_END_S,       ///< End of a subject ('.')
-	SEP_END_P,       ///< End of a predicate (';')
-	SEP_END_O,       ///< End of an object (',')
-	SEP_S_P,         ///< Between a subject and predicate (whitespace)
-	SEP_P_O,         ///< Between a predicate and object (whitespace)
-	SEP_ANON_BEGIN,  ///< Start of anonymous node ('[')
-	SEP_ANON_END,    ///< End of anonymous node (']')
-	SEP_LIST_BEGIN,  ///< Start of list ('(')
-	SEP_LIST_SEP,    ///< List separator (whitespace)
-	SEP_LIST_END,    ///< End of list (')')
-	SEP_GRAPH_BEGIN, ///< Start of graph ('{')
-	SEP_GRAPH_END,   ///< End of graph ('}')
-	SEP_URI_BEGIN,   ///< URI start quote ('<')
-	SEP_URI_END      ///< URI end quote ('>')
+  SEP_NONE,
+  SEP_END_S,       ///< End of a subject ('.')
+  SEP_END_P,       ///< End of a predicate (';')
+  SEP_END_O,       ///< End of an object (',')
+  SEP_S_P,         ///< Between a subject and predicate (whitespace)
+  SEP_P_O,         ///< Between a predicate and object (whitespace)
+  SEP_ANON_BEGIN,  ///< Start of anonymous node ('[')
+  SEP_ANON_END,    ///< End of anonymous node (']')
+  SEP_LIST_BEGIN,  ///< Start of list ('(')
+  SEP_LIST_SEP,    ///< List separator (whitespace)
+  SEP_LIST_END,    ///< End of list (')')
+  SEP_GRAPH_BEGIN, ///< Start of graph ('{')
+  SEP_GRAPH_END,   ///< End of graph ('}')
+  SEP_URI_BEGIN,   ///< URI start quote ('<')
+  SEP_URI_END      ///< URI end quote ('>')
 } Sep;
 
 typedef struct {
-	const char* str;               ///< Sep string
-	uint8_t     len;               ///< Length of sep string
-	uint8_t     space_before;      ///< Newline before sep
-	uint8_t     space_after_node;  ///< Newline after sep if after node
-	uint8_t     space_after_sep;   ///< Newline after sep if after sep
+  const char* str;              ///< Sep string
+  uint8_t     len;              ///< Length of sep string
+  uint8_t     space_before;     ///< Newline before sep
+  uint8_t     space_after_node; ///< Newline after sep if after node
+  uint8_t     space_after_sep;  ///< Newline after sep if after sep
 } SepRule;
 
-static const SepRule rules[] = {
-	{ NULL,     0, 0, 0, 0 },
-	{ " .\n\n", 4, 0, 0, 0 },
-	{ " ;",     2, 0, 1, 1 },
-	{ " ,",     2, 0, 1, 0 },
-	{ NULL,     0, 0, 1, 0 },
-	{ " ",      1, 0, 0, 0 },
-	{ "[",      1, 0, 1, 1 },
-	{ "]",      1, 1, 0, 0 },
-	{ "(",      1, 0, 0, 0 },
-	{ NULL,     0, 0, 1, 0 },
-	{ ")",      1, 1, 0, 0 },
-	{ " {",     2, 0, 1, 1 },
-	{ " }",     2, 0, 1, 1 },
-	{ "<",      1, 0, 0, 0 },
-	{ ">",      1, 0, 0, 0 },
-	{ "\n",     1, 0, 1, 0 }
-};
+static const SepRule rules[] = {{NULL, 0, 0, 0, 0},
+                                {" .\n\n", 4, 0, 0, 0},
+                                {" ;", 2, 0, 1, 1},
+                                {" ,", 2, 0, 1, 0},
+                                {NULL, 0, 0, 1, 0},
+                                {" ", 1, 0, 0, 0},
+                                {"[", 1, 0, 1, 1},
+                                {"]", 1, 1, 0, 0},
+                                {"(", 1, 0, 0, 0},
+                                {NULL, 0, 0, 1, 0},
+                                {")", 1, 1, 0, 0},
+                                {" {", 2, 0, 1, 1},
+                                {" }", 2, 0, 1, 1},
+                                {"<", 1, 0, 0, 0},
+                                {">", 1, 0, 0, 0},
+                                {"\n", 1, 0, 1, 0}};
 
 struct SerdWriterImpl {
-	SerdSyntax    syntax;
-	SerdStyle     style;
-	SerdEnv*      env;
-	SerdNode      root_node;
-	SerdURI       root_uri;
-	SerdURI       base_uri;
-	SerdStack     anon_stack;
-	SerdByteSink  byte_sink;
-	SerdErrorSink error_sink;
-	void*         error_handle;
-	WriteContext  context;
-	SerdNode      list_subj;
-	unsigned      list_depth;
-	unsigned      indent;
-	uint8_t*      bprefix;
-	size_t        bprefix_len;
-	Sep           last_sep;
-	bool          empty;
+  SerdSyntax    syntax;
+  SerdStyle     style;
+  SerdEnv*      env;
+  SerdNode      root_node;
+  SerdURI       root_uri;
+  SerdURI       base_uri;
+  SerdStack     anon_stack;
+  SerdByteSink  byte_sink;
+  SerdErrorSink error_sink;
+  void*         error_handle;
+  WriteContext  context;
+  SerdNode      list_subj;
+  unsigned      list_depth;
+  unsigned      indent;
+  uint8_t*      bprefix;
+  size_t        bprefix_len;
+  Sep           last_sep;
+  bool          empty;
 };
 
-typedef enum {
-	WRITE_STRING,
-	WRITE_LONG_STRING
-} TextContext;
+typedef enum { WRITE_STRING, WRITE_LONG_STRING } TextContext;
 
 static bool
 write_node(SerdWriter*        writer,
@@ -132,58 +125,58 @@ write_node(SerdWriter*        writer,
 static bool
 supports_abbrev(const SerdWriter* writer)
 {
-	return writer->syntax == SERD_TURTLE || writer->syntax == SERD_TRIG;
+  return writer->syntax == SERD_TURTLE || writer->syntax == SERD_TRIG;
 }
 
 static bool
 supports_uriref(const SerdWriter* writer)
 {
-	return writer->syntax == SERD_TURTLE || writer->syntax == SERD_TRIG;
+  return writer->syntax == SERD_TURTLE || writer->syntax == SERD_TRIG;
 }
 
 static void
 w_err(SerdWriter* writer, SerdStatus st, const char* fmt, ...)
 {
-	/* TODO: This results in errors with no file information, which is not
-	   helpful when re-serializing a file (particularly for "undefined
-	   namespace prefix" errors.  The statement sink API needs to be changed to
-	   add a Cursor parameter so the source can notify the writer of the
-	   statement origin for better error reporting. */
-
-	va_list args;
-	va_start(args, fmt);
-	const SerdError e = { st, (const uint8_t*)"", 0, 0, fmt, &args };
-	serd_error(writer->error_sink, writer->error_handle, &e);
-	va_end(args);
+  /* TODO: This results in errors with no file information, which is not
+     helpful when re-serializing a file (particularly for "undefined
+     namespace prefix" errors.  The statement sink API needs to be changed to
+     add a Cursor parameter so the source can notify the writer of the
+     statement origin for better error reporting. */
+
+  va_list args;
+  va_start(args, fmt);
+  const SerdError e = {st, (const uint8_t*)"", 0, 0, fmt, &args};
+  serd_error(writer->error_sink, writer->error_handle, &e);
+  va_end(args);
 }
 
 static inline WriteContext*
 anon_stack_top(SerdWriter* writer)
 {
-	assert(!serd_stack_is_empty(&writer->anon_stack));
-	return (WriteContext*)(writer->anon_stack.buf
-	                       + writer->anon_stack.size - sizeof(WriteContext));
+  assert(!serd_stack_is_empty(&writer->anon_stack));
+  return (WriteContext*)(writer->anon_stack.buf + writer->anon_stack.size -
+                         sizeof(WriteContext));
 }
 
 static void
 copy_node(SerdNode* dst, const SerdNode* src)
 {
-	if (src) {
-		dst->buf = (uint8_t*)realloc((char*)dst->buf, src->n_bytes + 1);
-		dst->n_bytes = src->n_bytes;
-		dst->n_chars = src->n_chars;
-		dst->flags   = src->flags;
-		dst->type    = src->type;
-		memcpy((char*)dst->buf, src->buf, src->n_bytes + 1);
-	} else {
-		dst->type = SERD_NOTHING;
-	}
+  if (src) {
+    dst->buf     = (uint8_t*)realloc((char*)dst->buf, src->n_bytes + 1);
+    dst->n_bytes = src->n_bytes;
+    dst->n_chars = src->n_chars;
+    dst->flags   = src->flags;
+    dst->type    = src->type;
+    memcpy((char*)dst->buf, src->buf, src->n_bytes + 1);
+  } else {
+    dst->type = SERD_NOTHING;
+  }
 }
 
 static inline size_t
 sink(const void* buf, size_t len, SerdWriter* writer)
 {
-	return serd_byte_sink_write(buf, len, &writer->byte_sink);
+  return serd_byte_sink_write(buf, len, &writer->byte_sink);
 }
 
 // Write a single character, as an escape for single byte characters
@@ -191,253 +184,310 @@ sink(const void* buf, size_t len, SerdWriter* writer)
 static size_t
 write_character(SerdWriter* writer, const uint8_t* utf8, size_t* size)
 {
-	char           escape[11] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-	const uint32_t c          = parse_utf8_char(utf8, size);
-	switch (*size) {
-	case 0:
-		w_err(writer, SERD_ERR_BAD_ARG, "invalid UTF-8: %X\n", utf8[0]);
-		return sink(replacement_char, sizeof(replacement_char), writer);
-	case 1:
-		snprintf(escape, sizeof(escape), "\\u%04X", utf8[0]);
-		return sink(escape, 6, writer);
-	default:
-		break;
-	}
-
-	if (!(writer->style & SERD_STYLE_ASCII)) {
-		// Write UTF-8 character directly to UTF-8 output
-		return sink(utf8, *size, writer);
-	}
-
-	if (c <= 0xFFFF) {
-		snprintf(escape, sizeof(escape), "\\u%04X", c);
-		return sink(escape, 6, writer);
-	}
-
-	snprintf(escape, sizeof(escape), "\\U%08X", c);
-	return sink(escape, 10, writer);
+  char           escape[11] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+  const uint32_t c          = parse_utf8_char(utf8, size);
+  switch (*size) {
+  case 0:
+    w_err(writer, SERD_ERR_BAD_ARG, "invalid UTF-8: %X\n", utf8[0]);
+    return sink(replacement_char, sizeof(replacement_char), writer);
+  case 1:
+    snprintf(escape, sizeof(escape), "\\u%04X", utf8[0]);
+    return sink(escape, 6, writer);
+  default:
+    break;
+  }
+
+  if (!(writer->style & SERD_STYLE_ASCII)) {
+    // Write UTF-8 character directly to UTF-8 output
+    return sink(utf8, *size, writer);
+  }
+
+  if (c <= 0xFFFF) {
+    snprintf(escape, sizeof(escape), "\\u%04X", c);
+    return sink(escape, 6, writer);
+  }
+
+  snprintf(escape, sizeof(escape), "\\U%08X", c);
+  return sink(escape, 10, writer);
 }
 
 static inline bool
 uri_must_escape(const uint8_t c)
 {
-	switch (c) {
-	case ' ': case '"': case '<': case '>': case '\\':
-	case '^': case '`': case '{': case '|': case '}':
-		return true;
-	default:
-		return !in_range(c, 0x20, 0x7E);
-	}
+  switch (c) {
+  case ' ':
+  case '"':
+  case '<':
+  case '>':
+  case '\\':
+  case '^':
+  case '`':
+  case '{':
+  case '|':
+  case '}':
+    return true;
+  default:
+    return !in_range(c, 0x20, 0x7E);
+  }
 }
 
 static size_t
 write_uri(SerdWriter* writer, const uint8_t* utf8, size_t n_bytes)
 {
-	size_t len = 0;
-	for (size_t i = 0; i < n_bytes;) {
-		size_t j = i;  // Index of next character that must be escaped
-		for (; j < n_bytes; ++j) {
-			if (uri_must_escape(utf8[j])) {
-				break;
-			}
-		}
-
-		// Bulk write all characters up to this special one
-		len += sink(&utf8[i], j - i, writer);
-		if ((i = j) == n_bytes) {
-			break;  // Reached end
-		}
-
-		// Write UTF-8 character
-		size_t size = 0;
-		len += write_character(writer, utf8 + i, &size);
-		i   += size;
-		if (size == 0) {
-			// Corrupt input, scan to start of next character
-			for (++i; i < n_bytes && (utf8[i] & 0x80); ++i) {}
-		}
-	}
-	return len;
+  size_t len = 0;
+  for (size_t i = 0; i < n_bytes;) {
+    size_t j = i; // Index of next character that must be escaped
+    for (; j < n_bytes; ++j) {
+      if (uri_must_escape(utf8[j])) {
+        break;
+      }
+    }
+
+    // Bulk write all characters up to this special one
+    len += sink(&utf8[i], j - i, writer);
+    if ((i = j) == n_bytes) {
+      break; // Reached end
+    }
+
+    // Write UTF-8 character
+    size_t size = 0;
+    len += write_character(writer, utf8 + i, &size);
+    i += size;
+    if (size == 0) {
+      // Corrupt input, scan to start of next character
+      for (++i; i < n_bytes && (utf8[i] & 0x80); ++i) {
+      }
+    }
+  }
+
+  return len;
 }
 
 static bool
 lname_must_escape(const uint8_t c)
 {
-	/* This arbitrary list of characters, most of which have nothing to do with
-	   Turtle, must be handled as special cases here because the RDF and SPARQL
-	   WGs are apparently intent on making the once elegant Turtle a baroque
-	   and inconsistent mess, throwing elegance and extensibility completely
-	   out the window for no good reason.
-
-	   Note '-', '.', and '_' are also in PN_LOCAL_ESC, but are valid unescaped
-	   in local names, so they are not escaped here. */
-
-	switch (c) {
-	case '\'': case '!': case '#': case '$': case '%': case '&':
-	case '(': case ')': case '*': case '+': case ',': case '/':
-	case ';': case '=': case '?': case '@': case '~':
-		return true;
-	default:
-		break;
-	}
-	return false;
+  /* This arbitrary list of characters, most of which have nothing to do with
+     Turtle, must be handled as special cases here because the RDF and SPARQL
+     WGs are apparently intent on making the once elegant Turtle a baroque
+     and inconsistent mess, throwing elegance and extensibility completely
+     out the window for no good reason.
+
+     Note '-', '.', and '_' are also in PN_LOCAL_ESC, but are valid unescaped
+     in local names, so they are not escaped here. */
+
+  switch (c) {
+  case '\'':
+  case '!':
+  case '#':
+  case '$':
+  case '%':
+  case '&':
+  case '(':
+  case ')':
+  case '*':
+  case '+':
+  case ',':
+  case '/':
+  case ';':
+  case '=':
+  case '?':
+  case '@':
+  case '~':
+    return true;
+  default:
+    break;
+  }
+  return false;
 }
 
 static size_t
 write_lname(SerdWriter* writer, const uint8_t* utf8, size_t n_bytes)
 {
-	size_t len = 0;
-	for (size_t i = 0; i < n_bytes; ++i) {
-		size_t j = i;  // Index of next character that must be escaped
-		for (; j < n_bytes; ++j) {
-			if (lname_must_escape(utf8[j])) {
-				break;
-			}
-		}
-
-		// Bulk write all characters up to this special one
-		len += sink(&utf8[i], j - i, writer);
-		if ((i = j) == n_bytes) {
-			break;  // Reached end
-		}
-
-		// Write escape
-		len += sink("\\", 1, writer);
-		len += sink(&utf8[i], 1, writer);
-	}
-	return len;
+  size_t len = 0;
+  for (size_t i = 0; i < n_bytes; ++i) {
+    size_t j = i; // Index of next character that must be escaped
+    for (; j < n_bytes; ++j) {
+      if (lname_must_escape(utf8[j])) {
+        break;
+      }
+    }
+
+    // Bulk write all characters up to this special one
+    len += sink(&utf8[i], j - i, writer);
+    if ((i = j) == n_bytes) {
+      break; // Reached end
+    }
+
+    // Write escape
+    len += sink("\\", 1, writer);
+    len += sink(&utf8[i], 1, writer);
+  }
+
+  return len;
 }
 
 static size_t
-write_text(SerdWriter* writer, TextContext ctx,
-           const uint8_t* utf8, size_t n_bytes)
+write_text(SerdWriter*    writer,
+           TextContext    ctx,
+           const uint8_t* utf8,
+           size_t         n_bytes)
 {
-	size_t len = 0;
-	for (size_t i = 0; i < n_bytes;) {
-		// Fast bulk write for long strings of printable ASCII
-		size_t j = i;
-		for (; j < n_bytes; ++j) {
-			if (utf8[j] == '\\' || utf8[j] == '"'
-			    || (!in_range(utf8[j], 0x20, 0x7E))) {
-				break;
-			}
-		}
-
-		len += sink(&utf8[i], j - i, writer);
-		if ((i = j) == n_bytes) {
-			break;  // Reached end
-		}
-
-		const uint8_t in = utf8[i++];
-		if (ctx == WRITE_LONG_STRING) {
-			switch (in) {
-			case '\\': len += sink("\\\\", 2, writer); continue;
-			case '\b': len += sink("\\b", 2, writer);  continue;
-			case '\n': case '\r': case '\t': case '\f':
-				len += sink(&in, 1, writer);  // Write character as-is
-				continue;
-			case '\"':
-				if (i == n_bytes) {  // '"' at string end
-					len += sink("\\\"", 2, writer);
-				} else {
-					len += sink(&in, 1, writer);
-				}
-				continue;
-			default: break;
-			}
-		} else if (ctx == WRITE_STRING) {
-			switch (in) {
-			case '\\': len += sink("\\\\", 2, writer); continue;
-			case '\n': len += sink("\\n", 2, writer);  continue;
-			case '\r': len += sink("\\r", 2, writer);  continue;
-			case '\t': len += sink("\\t", 2, writer);  continue;
-			case '"':  len += sink("\\\"", 2, writer); continue;
-			default: break;
-			}
-			if (writer->syntax == SERD_TURTLE) {
-				switch (in) {
-				case '\b': len += sink("\\b", 2, writer); continue;
-				case '\f': len += sink("\\f", 2, writer); continue;
-				default: break;
-				}
-			}
-		}
-
-		// Write UTF-8 character
-		size_t size = 0;
-		len += write_character(writer, utf8 + i - 1, &size);
-		if (size == 0) {
-			// Corrupt input, scan to start of next character
-			for (; i < n_bytes && (utf8[i] & 0x80); ++i) {}
-		} else {
-			i += size - 1;
-		}
-	}
-	return len;
+  size_t len = 0;
+  for (size_t i = 0; i < n_bytes;) {
+    // Fast bulk write for long strings of printable ASCII
+    size_t j = i;
+    for (; j < n_bytes; ++j) {
+      if (utf8[j] == '\\' || utf8[j] == '"' ||
+          (!in_range(utf8[j], 0x20, 0x7E))) {
+        break;
+      }
+    }
+
+    len += sink(&utf8[i], j - i, writer);
+    if ((i = j) == n_bytes) {
+      break; // Reached end
+    }
+
+    const uint8_t in = utf8[i++];
+    if (ctx == WRITE_LONG_STRING) {
+      switch (in) {
+      case '\\':
+        len += sink("\\\\", 2, writer);
+        continue;
+      case '\b':
+        len += sink("\\b", 2, writer);
+        continue;
+      case '\n':
+      case '\r':
+      case '\t':
+      case '\f':
+        len += sink(&in, 1, writer); // Write character as-is
+        continue;
+      case '\"':
+        if (i == n_bytes) { // '"' at string end
+          len += sink("\\\"", 2, writer);
+        } else {
+          len += sink(&in, 1, writer);
+        }
+        continue;
+      default:
+        break;
+      }
+    } else if (ctx == WRITE_STRING) {
+      switch (in) {
+      case '\\':
+        len += sink("\\\\", 2, writer);
+        continue;
+      case '\n':
+        len += sink("\\n", 2, writer);
+        continue;
+      case '\r':
+        len += sink("\\r", 2, writer);
+        continue;
+      case '\t':
+        len += sink("\\t", 2, writer);
+        continue;
+      case '"':
+        len += sink("\\\"", 2, writer);
+        continue;
+      default:
+        break;
+      }
+      if (writer->syntax == SERD_TURTLE) {
+        switch (in) {
+        case '\b':
+          len += sink("\\b", 2, writer);
+          continue;
+        case '\f':
+          len += sink("\\f", 2, writer);
+          continue;
+        default:
+          break;
+        }
+      }
+    }
+
+    // Write UTF-8 character
+    size_t size = 0;
+    len += write_character(writer, utf8 + i - 1, &size);
+    if (size == 0) {
+      // Corrupt input, scan to start of next character
+      for (; i < n_bytes && (utf8[i] & 0x80); ++i) {
+      }
+    } else {
+      i += size - 1;
+    }
+  }
+
+  return len;
 }
 
 static size_t
 uri_sink(const void* buf, size_t len, void* stream)
 {
-	return write_uri((SerdWriter*)stream, (const uint8_t*)buf, len);
+  return write_uri((SerdWriter*)stream, (const uint8_t*)buf, len);
 }
 
 static void
 write_newline(SerdWriter* writer)
 {
-	sink("\n", 1, writer);
-	for (unsigned i = 0; i < writer->indent; ++i) {
-		sink("\t", 1, writer);
-	}
+  sink("\n", 1, writer);
+  for (unsigned i = 0; i < writer->indent; ++i) {
+    sink("\t", 1, writer);
+  }
 }
 
 static bool
 write_sep(SerdWriter* writer, const Sep sep)
 {
-	const SepRule* rule = &rules[sep];
-	if (rule->space_before) {
-		write_newline(writer);
-	}
-	if (rule->str) {
-		sink(rule->str, rule->len, writer);
-	}
-	if ((writer->last_sep && rule->space_after_sep) ||
-	    (!writer->last_sep && rule->space_after_node)) {
-		write_newline(writer);
-	} else if (writer->last_sep && rule->space_after_node) {
-		sink(" ", 1, writer);
-	}
-	writer->last_sep = sep;
-	return true;
+  const SepRule* rule = &rules[sep];
+  if (rule->space_before) {
+    write_newline(writer);
+  }
+
+  if (rule->str) {
+    sink(rule->str, rule->len, writer);
+  }
+
+  if ((writer->last_sep && rule->space_after_sep) ||
+      (!writer->last_sep && rule->space_after_node)) {
+    write_newline(writer);
+  } else if (writer->last_sep && rule->space_after_node) {
+    sink(" ", 1, writer);
+  }
+
+  writer->last_sep = sep;
+  return true;
 }
 
 static SerdStatus
 reset_context(SerdWriter* writer, bool graph)
 {
-	if (graph) {
-		writer->context.graph.type = SERD_NOTHING;
-	}
-	writer->context.subject.type   = SERD_NOTHING;
-	writer->context.predicate.type = SERD_NOTHING;
-	writer->empty                  = false;
-	return SERD_SUCCESS;
+  if (graph) {
+    writer->context.graph.type = SERD_NOTHING;
+  }
+
+  writer->context.subject.type   = SERD_NOTHING;
+  writer->context.predicate.type = SERD_NOTHING;
+  writer->empty                  = false;
+  return SERD_SUCCESS;
 }
 
 static SerdStatus
 free_context(SerdWriter* writer)
 {
-	serd_node_free(&writer->context.graph);
-	serd_node_free(&writer->context.subject);
-	serd_node_free(&writer->context.predicate);
-	return reset_context(writer, true);
+  serd_node_free(&writer->context.graph);
+  serd_node_free(&writer->context.subject);
+  serd_node_free(&writer->context.predicate);
+  return reset_context(writer, true);
 }
 
 static bool
 is_inline_start(const SerdWriter* writer, Field field, SerdStatementFlags flags)
 {
-	return (supports_abbrev(writer) &&
-	        ((field == FIELD_SUBJECT && (flags & SERD_ANON_S_BEGIN)) ||
-	         (field == FIELD_OBJECT &&  (flags & SERD_ANON_O_BEGIN))));
+  return (supports_abbrev(writer) &&
+          ((field == FIELD_SUBJECT && (flags & SERD_ANON_S_BEGIN)) ||
+           (field == FIELD_OBJECT && (flags & SERD_ANON_O_BEGIN))));
 }
 
 static bool
@@ -447,59 +497,60 @@ write_literal(SerdWriter*        writer,
               const SerdNode*    lang,
               SerdStatementFlags flags)
 {
-	if (supports_abbrev(writer) && datatype && datatype->buf) {
-		const char* type_uri = (const char*)datatype->buf;
-		if (!strncmp(type_uri, NS_XSD, sizeof(NS_XSD) - 1) && (
-			    !strcmp(type_uri + sizeof(NS_XSD) - 1, "boolean") ||
-			    !strcmp(type_uri + sizeof(NS_XSD) - 1, "integer"))) {
-			sink(node->buf, node->n_bytes, writer);
-			return true;
-		}
-
-		if (!strncmp(type_uri, NS_XSD, sizeof(NS_XSD) - 1) &&
-		    !strcmp(type_uri + sizeof(NS_XSD) - 1, "decimal") &&
-		    strchr((const char*)node->buf, '.') &&
-		    node->buf[node->n_bytes - 1] != '.') {
-			/* xsd:decimal literals without trailing digits, e.g. "5.", can
-			   not be written bare in Turtle.  We could add a 0 which is
-			   prettier, but changes the text and breaks round tripping.
-			*/
-			sink(node->buf, node->n_bytes, writer);
-			return true;
-		}
-	}
-
-	if (supports_abbrev(writer)
-	    && (node->flags & (SERD_HAS_NEWLINE|SERD_HAS_QUOTE))) {
-		sink("\"\"\"", 3, writer);
-		write_text(writer, WRITE_LONG_STRING, node->buf, node->n_bytes);
-		sink("\"\"\"", 3, writer);
-	} else {
-		sink("\"", 1, writer);
-		write_text(writer, WRITE_STRING, node->buf, node->n_bytes);
-		sink("\"", 1, writer);
-	}
-	if (lang && lang->buf) {
-		sink("@", 1, writer);
-		sink(lang->buf, lang->n_bytes, writer);
-	} else if (datatype && datatype->buf) {
-		sink("^^", 2, writer);
-		return write_node(writer, datatype, NULL, NULL, FIELD_NONE, flags);
-	}
-	return true;
+  if (supports_abbrev(writer) && datatype && datatype->buf) {
+    const char* type_uri = (const char*)datatype->buf;
+    if (!strncmp(type_uri, NS_XSD, sizeof(NS_XSD) - 1) &&
+        (!strcmp(type_uri + sizeof(NS_XSD) - 1, "boolean") ||
+         !strcmp(type_uri + sizeof(NS_XSD) - 1, "integer"))) {
+      sink(node->buf, node->n_bytes, writer);
+      return true;
+    }
+
+    if (!strncmp(type_uri, NS_XSD, sizeof(NS_XSD) - 1) &&
+        !strcmp(type_uri + sizeof(NS_XSD) - 1, "decimal") &&
+        strchr((const char*)node->buf, '.') &&
+        node->buf[node->n_bytes - 1] != '.') {
+      /* xsd:decimal literals without trailing digits, e.g. "5.", can
+         not be written bare in Turtle.  We could add a 0 which is
+         prettier, but changes the text and breaks round tripping.
+      */
+      sink(node->buf, node->n_bytes, writer);
+      return true;
+    }
+  }
+
+  if (supports_abbrev(writer) &&
+      (node->flags & (SERD_HAS_NEWLINE | SERD_HAS_QUOTE))) {
+    sink("\"\"\"", 3, writer);
+    write_text(writer, WRITE_LONG_STRING, node->buf, node->n_bytes);
+    sink("\"\"\"", 3, writer);
+  } else {
+    sink("\"", 1, writer);
+    write_text(writer, WRITE_STRING, node->buf, node->n_bytes);
+    sink("\"", 1, writer);
+  }
+  if (lang && lang->buf) {
+    sink("@", 1, writer);
+    sink(lang->buf, lang->n_bytes, writer);
+  } else if (datatype && datatype->buf) {
+    sink("^^", 2, writer);
+    return write_node(writer, datatype, NULL, NULL, FIELD_NONE, flags);
+  }
+  return true;
 }
 
 // Return true iff `buf` is a valid prefixed name suffix
 static inline bool
 is_name(const uint8_t* buf, const size_t len)
 {
-	// TODO: This is more strict than it should be.
-	for (size_t i = 0; i < len; ++i) {
-		if (!(is_alpha(buf[i]) || is_digit(buf[i]))) {
-			return false;
-		}
-	}
-	return true;
+  // TODO: This is more strict than it should be
+  for (size_t i = 0; i < len; ++i) {
+    if (!(is_alpha(buf[i]) || is_digit(buf[i]))) {
+      return false;
+    }
+  }
+
+  return true;
 }
 
 static bool
@@ -508,72 +559,73 @@ write_uri_node(SerdWriter* const        writer,
                const Field              field,
                const SerdStatementFlags flags)
 {
-	SerdNode  prefix;
-	SerdChunk suffix;
-
-	if (is_inline_start(writer, field, flags)) {
-		++writer->indent;
-		write_sep(writer, SEP_ANON_BEGIN);
-		sink("== ", 3, writer);
-	}
-
-	const bool has_scheme = serd_uri_string_has_scheme(node->buf);
-	if (supports_abbrev(writer)) {
-		if (field == FIELD_PREDICATE &&
-		    !strcmp((const char*)node->buf, NS_RDF "type")) {
-			return sink("a", 1, writer) == 1;
-		}
-
-		if (!strcmp((const char*)node->buf, NS_RDF "nil")) {
-			return sink("()", 2, writer) == 2;
-		}
-
-		if (has_scheme && (writer->style & SERD_STYLE_CURIED) &&
-		    serd_env_qualify(writer->env, node, &prefix, &suffix) &&
-		    is_name(suffix.buf, suffix.len)) {
-			write_uri(writer, prefix.buf, prefix.n_bytes);
-			sink(":", 1, writer);
-			write_uri(writer, suffix.buf, suffix.len);
-			return true;
-		}
-	}
-
-	if (!has_scheme && !supports_uriref(writer) &&
-	    !serd_env_get_base_uri(writer->env, NULL)->buf) {
-		w_err(writer,
-		      SERD_ERR_BAD_ARG,
-		      "syntax does not support URI reference <%s>\n",
-		      node->buf);
-		return false;
-	}
-
-	write_sep(writer, SEP_URI_BEGIN);
-	if (writer->style & SERD_STYLE_RESOLVED) {
-		SerdURI in_base_uri;
-		SerdURI uri;
-		SerdURI abs_uri;
-		serd_env_get_base_uri(writer->env, &in_base_uri);
-		serd_uri_parse(node->buf, &uri);
-		serd_uri_resolve(&uri, &in_base_uri, &abs_uri);
-		bool rooted = uri_is_under(&writer->base_uri, &writer->root_uri);
-		SerdURI* root = rooted ? &writer->root_uri : & writer->base_uri;
-		if (!uri_is_under(&abs_uri, root) ||
-		    writer->syntax == SERD_NTRIPLES ||
-		    writer->syntax == SERD_NQUADS) {
-			serd_uri_serialise(&abs_uri, uri_sink, writer);
-		} else {
-			serd_uri_serialise_relative(
-				&uri, &writer->base_uri, root, uri_sink, writer);
-		}
-	} else {
-		write_uri(writer, node->buf, node->n_bytes);
-	}
-	write_sep(writer, SEP_URI_END);
-	if (is_inline_start(writer, field, flags)) {
-		sink(" ;", 2, writer);
-		write_newline(writer);
-	}
-	return true;
+  SerdNode  prefix;
+  SerdChunk suffix;
+
+  if (is_inline_start(writer, field, flags)) {
+    ++writer->indent;
+    write_sep(writer, SEP_ANON_BEGIN);
+    sink("== ", 3, writer);
+  }
+
+  const bool has_scheme = serd_uri_string_has_scheme(node->buf);
+  if (supports_abbrev(writer)) {
+    if (field == FIELD_PREDICATE &&
+        !strcmp((const char*)node->buf, NS_RDF "type")) {
+      return sink("a", 1, writer) == 1;
+    }
+
+    if (!strcmp((const char*)node->buf, NS_RDF "nil")) {
+      return sink("()", 2, writer) == 2;
+    }
+
+    if (has_scheme && (writer->style & SERD_STYLE_CURIED) &&
+        serd_env_qualify(writer->env, node, &prefix, &suffix) &&
+        is_name(suffix.buf, suffix.len)) {
+      write_uri(writer, prefix.buf, prefix.n_bytes);
+      sink(":", 1, writer);
+      write_uri(writer, suffix.buf, suffix.len);
+      return true;
+    }
+  }
+
+  if (!has_scheme && !supports_uriref(writer) &&
+      !serd_env_get_base_uri(writer->env, NULL)->buf) {
+    w_err(writer,
+          SERD_ERR_BAD_ARG,
+          "syntax does not support URI reference <%s>\n",
+          node->buf);
+    return false;
+  }
+
+  write_sep(writer, SEP_URI_BEGIN);
+  if (writer->style & SERD_STYLE_RESOLVED) {
+    SerdURI in_base_uri;
+    SerdURI uri;
+    SerdURI abs_uri;
+    serd_env_get_base_uri(writer->env, &in_base_uri);
+    serd_uri_parse(node->buf, &uri);
+    serd_uri_resolve(&uri, &in_base_uri, &abs_uri);
+    bool     rooted = uri_is_under(&writer->base_uri, &writer->root_uri);
+    SerdURI* root   = rooted ? &writer->root_uri : &writer->base_uri;
+    if (!uri_is_under(&abs_uri, root) || writer->syntax == SERD_NTRIPLES ||
+        writer->syntax == SERD_NQUADS) {
+      serd_uri_serialise(&abs_uri, uri_sink, writer);
+    } else {
+      serd_uri_serialise_relative(
+        &uri, &writer->base_uri, root, uri_sink, writer);
+    }
+  } else {
+    write_uri(writer, node->buf, node->n_bytes);
+  }
+
+  write_sep(writer, SEP_URI_END);
+  if (is_inline_start(writer, field, flags)) {
+    sink(" ;", 2, writer);
+    write_newline(writer);
+  }
+
+  return true;
 }
 
 static bool
@@ -582,36 +634,37 @@ write_curie(SerdWriter* const        writer,
             const Field              field,
             const SerdStatementFlags flags)
 {
-	SerdChunk  prefix = {NULL, 0};
-	SerdChunk  suffix = {NULL, 0};
-	SerdStatus st     = SERD_SUCCESS;
-
-	switch (writer->syntax) {
-	case SERD_NTRIPLES:
-	case SERD_NQUADS:
-		if ((st = serd_env_expand(writer->env, node, &prefix, &suffix))) {
-			w_err(writer, st, "undefined namespace prefix `%s'\n", node->buf);
-			return false;
-		}
-		write_sep(writer, SEP_URI_BEGIN);
-		write_uri(writer, prefix.buf, prefix.len);
-		write_uri(writer, suffix.buf, suffix.len);
-		write_sep(writer, SEP_URI_END);
-		break;
-	case SERD_TURTLE:
-	case SERD_TRIG:
-		if (is_inline_start(writer, field, flags)) {
-			++writer->indent;
-			write_sep(writer, SEP_ANON_BEGIN);
-			sink("== ", 3, writer);
-		}
-		write_lname(writer, node->buf, node->n_bytes);
-		if (is_inline_start(writer, field, flags)) {
-			sink(" ;", 2, writer);
-			write_newline(writer);
-		}
-	}
-	return true;
+  SerdChunk  prefix = {NULL, 0};
+  SerdChunk  suffix = {NULL, 0};
+  SerdStatus st     = SERD_SUCCESS;
+
+  switch (writer->syntax) {
+  case SERD_NTRIPLES:
+  case SERD_NQUADS:
+    if ((st = serd_env_expand(writer->env, node, &prefix, &suffix))) {
+      w_err(writer, st, "undefined namespace prefix `%s'\n", node->buf);
+      return false;
+    }
+    write_sep(writer, SEP_URI_BEGIN);
+    write_uri(writer, prefix.buf, prefix.len);
+    write_uri(writer, suffix.buf, suffix.len);
+    write_sep(writer, SEP_URI_END);
+    break;
+  case SERD_TURTLE:
+  case SERD_TRIG:
+    if (is_inline_start(writer, field, flags)) {
+      ++writer->indent;
+      write_sep(writer, SEP_ANON_BEGIN);
+      sink("== ", 3, writer);
+    }
+    write_lname(writer, node->buf, node->n_bytes);
+    if (is_inline_start(writer, field, flags)) {
+      sink(" ;", 2, writer);
+      write_newline(writer);
+    }
+  }
+
+  return true;
 }
 
 static bool
@@ -620,44 +673,44 @@ write_blank(SerdWriter* const        writer,
             const Field              field,
             const SerdStatementFlags flags)
 {
-	if (supports_abbrev(writer)) {
-		if (is_inline_start(writer, field, flags)) {
-			++writer->indent;
-			return write_sep(writer, SEP_ANON_BEGIN);
-		}
-
-		if (field == FIELD_SUBJECT && (flags & SERD_LIST_S_BEGIN)) {
-			assert(writer->list_depth == 0);
-			copy_node(&writer->list_subj, node);
-			++writer->list_depth;
-			++writer->indent;
-			return write_sep(writer, SEP_LIST_BEGIN);
-		}
-
-		if (field == FIELD_OBJECT && (flags & SERD_LIST_O_BEGIN)) {
-			++writer->indent;
-			++writer->list_depth;
-			return write_sep(writer, SEP_LIST_BEGIN);
-		}
-
-		if ((field == FIELD_SUBJECT && (flags & SERD_EMPTY_S)) ||
-		    (field == FIELD_OBJECT && (flags & SERD_EMPTY_O))) {
-			return sink("[]", 2, writer) == 2;
-		}
-	}
-
-	sink("_:", 2, writer);
-	if (writer->bprefix && !strncmp((const char*)node->buf,
-	                                (const char*)writer->bprefix,
-	                                writer->bprefix_len)) {
-		sink(node->buf + writer->bprefix_len,
-		     node->n_bytes - writer->bprefix_len,
-		     writer);
-	} else {
-		sink(node->buf, node->n_bytes, writer);
-	}
-
-	return true;
+  if (supports_abbrev(writer)) {
+    if (is_inline_start(writer, field, flags)) {
+      ++writer->indent;
+      return write_sep(writer, SEP_ANON_BEGIN);
+    }
+
+    if (field == FIELD_SUBJECT && (flags & SERD_LIST_S_BEGIN)) {
+      assert(writer->list_depth == 0);
+      copy_node(&writer->list_subj, node);
+      ++writer->list_depth;
+      ++writer->indent;
+      return write_sep(writer, SEP_LIST_BEGIN);
+    }
+
+    if (field == FIELD_OBJECT && (flags & SERD_LIST_O_BEGIN)) {
+      ++writer->indent;
+      ++writer->list_depth;
+      return write_sep(writer, SEP_LIST_BEGIN);
+    }
+
+    if ((field == FIELD_SUBJECT && (flags & SERD_EMPTY_S)) ||
+        (field == FIELD_OBJECT && (flags & SERD_EMPTY_O))) {
+      return sink("[]", 2, writer) == 2;
+    }
+  }
+
+  sink("_:", 2, writer);
+  if (writer->bprefix && !strncmp((const char*)node->buf,
+                                  (const char*)writer->bprefix,
+                                  writer->bprefix_len)) {
+    sink(node->buf + writer->bprefix_len,
+         node->n_bytes - writer->bprefix_len,
+         writer);
+  } else {
+    sink(node->buf, node->n_bytes, writer);
+  }
+
+  return true;
 }
 
 static bool
@@ -668,39 +721,40 @@ write_node(SerdWriter*        writer,
            Field              field,
            SerdStatementFlags flags)
 {
-	bool ret = false;
-	switch (node->type) {
-	case SERD_NOTHING:
-		break;
-	case SERD_LITERAL:
-		ret = write_literal(writer, node, datatype, lang, flags);
-		break;
-	case SERD_URI:
-		ret = write_uri_node(writer, node, field, flags);
-		break;
-	case SERD_CURIE:
-		ret = write_curie(writer, node, field, flags);
-		break;
-	case SERD_BLANK:
-		ret = write_blank(writer, node, field, flags);
-		break;
-	}
-	writer->last_sep = SEP_NONE;
-	return ret;
+  bool ret = false;
+  switch (node->type) {
+  case SERD_NOTHING:
+    break;
+  case SERD_LITERAL:
+    ret = write_literal(writer, node, datatype, lang, flags);
+    break;
+  case SERD_URI:
+    ret = write_uri_node(writer, node, field, flags);
+    break;
+  case SERD_CURIE:
+    ret = write_curie(writer, node, field, flags);
+    break;
+  case SERD_BLANK:
+    ret = write_blank(writer, node, field, flags);
+    break;
+  }
+
+  writer->last_sep = SEP_NONE;
+  return ret;
 }
 
 static inline bool
 is_resource(const SerdNode* node)
 {
-	return node && node->buf && node->type > SERD_LITERAL;
+  return node && node->buf && node->type > SERD_LITERAL;
 }
 
 static void
 write_pred(SerdWriter* writer, SerdStatementFlags flags, const SerdNode* pred)
 {
-	write_node(writer, pred, NULL, NULL, FIELD_PREDICATE, flags);
-	write_sep(writer, SEP_P_O);
-	copy_node(&writer->context.predicate, pred);
+  write_node(writer, pred, NULL, NULL, FIELD_PREDICATE, flags);
+  write_sep(writer, SEP_P_O);
+  copy_node(&writer->context.predicate, pred);
 }
 
 static bool
@@ -711,18 +765,18 @@ write_list_obj(SerdWriter*        writer,
                const SerdNode*    datatype,
                const SerdNode*    lang)
 {
-	if (!strcmp((const char*)object->buf, NS_RDF "nil")) {
-		--writer->indent;
-		write_sep(writer, SEP_LIST_END);
-		return true;
-	}
-
-	if (!strcmp((const char*)predicate->buf, NS_RDF "first")) {
-		write_sep(writer, SEP_LIST_SEP);
-		write_node(writer, object, datatype, lang, FIELD_OBJECT, flags);
-	}
-
-	return false;
+  if (!strcmp((const char*)object->buf, NS_RDF "nil")) {
+    --writer->indent;
+    write_sep(writer, SEP_LIST_END);
+    return true;
+  }
+
+  if (!strcmp((const char*)predicate->buf, NS_RDF "first")) {
+    write_sep(writer, SEP_LIST_SEP);
+    write_node(writer, object, datatype, lang, FIELD_OBJECT, flags);
+  }
+
+  return false;
 }
 
 SerdStatus
@@ -735,166 +789,171 @@ serd_writer_write_statement(SerdWriter*        writer,
                             const SerdNode*    datatype,
                             const SerdNode*    lang)
 {
-	if (!is_resource(subject) || !is_resource(predicate) || !object ||
-	    !object->buf) {
-		return SERD_ERR_BAD_ARG;
-	}
-
-#define TRY(write_result) \
-	do { \
-		if (!(write_result)) { \
-			return SERD_ERR_UNKNOWN; \
-		} \
-	} while (0)
-
-	if (writer->syntax == SERD_NTRIPLES || writer->syntax == SERD_NQUADS) {
-		TRY(write_node(writer, subject, NULL, NULL, FIELD_SUBJECT, flags));
-		sink(" ", 1, writer);
-		TRY(write_node(writer, predicate, NULL, NULL, FIELD_PREDICATE, flags));
-		sink(" ", 1, writer);
-		TRY(write_node(writer, object, datatype, lang, FIELD_OBJECT, flags));
-		if (writer->syntax == SERD_NQUADS && graph) {
-			sink(" ", 1, writer);
-			TRY(write_node(writer, graph, datatype, lang, FIELD_GRAPH, flags));
-		}
-		sink(" .\n", 3, writer);
-		return SERD_SUCCESS;
-	}
-
-	if ((graph && !serd_node_equals(graph, &writer->context.graph)) ||
-	    (!graph && writer->context.graph.type)) {
-		writer->indent = 0;
-		if (writer->context.subject.type) {
-			write_sep(writer, SEP_END_S);
-		}
-		if (writer->context.graph.type) {
-			write_sep(writer, SEP_GRAPH_END);
-		}
-
-		reset_context(writer, true);
-		if (graph) {
-			TRY(write_node(writer, graph, datatype, lang, FIELD_GRAPH, flags));
-			++writer->indent;
-			write_sep(writer, SEP_GRAPH_BEGIN);
-			copy_node(&writer->context.graph, graph);
-		}
-	}
-
-	if ((flags & SERD_LIST_CONT)) {
-		if (write_list_obj(writer, flags, predicate, object, datatype, lang)) {
-			// Reached end of list
-			if (--writer->list_depth == 0 && writer->list_subj.type) {
-				reset_context(writer, false);
-				serd_node_free(&writer->context.subject);
-				writer->context.subject = writer->list_subj;
-				writer->list_subj       = SERD_NODE_NULL;
-			}
-			return SERD_SUCCESS;
-		}
-	} else if (serd_node_equals(subject, &writer->context.subject)) {
-		if (serd_node_equals(predicate, &writer->context.predicate)) {
-			// Abbreviate S P
-			if (!(flags & SERD_ANON_O_BEGIN)) {
-				++writer->indent;
-			}
-			write_sep(writer, SEP_END_O);
-			write_node(writer, object, datatype, lang, FIELD_OBJECT, flags);
-			if (!(flags & SERD_ANON_O_BEGIN)) {
-				--writer->indent;
-			}
-		} else {
-			// Abbreviate S
-			Sep sep = writer->context.predicate.type ? SEP_END_P : SEP_S_P;
-			write_sep(writer, sep);
-			write_pred(writer, flags, predicate);
-			write_node(writer, object, datatype, lang, FIELD_OBJECT, flags);
-		}
-	} else {
-		// No abbreviation
-		if (writer->context.subject.type) {
-			assert(writer->indent > 0);
-			--writer->indent;
-			if (serd_stack_is_empty(&writer->anon_stack)) {
-				write_sep(writer, SEP_END_S);
-			}
-		} else if (!writer->empty) {
-			write_sep(writer, SEP_S_P);
-		}
-
-		if (!(flags & SERD_ANON_CONT)) {
-			write_node(writer, subject, NULL, NULL, FIELD_SUBJECT, flags);
-			++writer->indent;
-			write_sep(writer, SEP_S_P);
-		} else {
-			++writer->indent;
-		}
-
-		reset_context(writer, false);
-		copy_node(&writer->context.subject, subject);
-
-		if (!(flags & SERD_LIST_S_BEGIN)) {
-			write_pred(writer, flags, predicate);
-		}
-
-		write_node(writer, object, datatype, lang, FIELD_OBJECT, flags);
-	}
-
-	if (flags & (SERD_ANON_S_BEGIN|SERD_ANON_O_BEGIN)) {
-		WriteContext* ctx = (WriteContext*)serd_stack_push(
-			&writer->anon_stack, sizeof(WriteContext));
-		*ctx = writer->context;
-		WriteContext new_context = {
-			serd_node_copy(graph), serd_node_copy(subject), SERD_NODE_NULL };
-		if ((flags & SERD_ANON_S_BEGIN)) {
-			new_context.predicate = serd_node_copy(predicate);
-		}
-		writer->context = new_context;
-	} else {
-		copy_node(&writer->context.graph, graph);
-		copy_node(&writer->context.subject, subject);
-		copy_node(&writer->context.predicate, predicate);
-	}
-
-	return SERD_SUCCESS;
+  if (!is_resource(subject) || !is_resource(predicate) || !object ||
+      !object->buf) {
+    return SERD_ERR_BAD_ARG;
+  }
+
+#define TRY(write_result)      \
+  do {                         \
+    if (!(write_result)) {     \
+      return SERD_ERR_UNKNOWN; \
+    }                          \
+  } while (0)
+
+  if (writer->syntax == SERD_NTRIPLES || writer->syntax == SERD_NQUADS) {
+    TRY(write_node(writer, subject, NULL, NULL, FIELD_SUBJECT, flags));
+    sink(" ", 1, writer);
+    TRY(write_node(writer, predicate, NULL, NULL, FIELD_PREDICATE, flags));
+    sink(" ", 1, writer);
+    TRY(write_node(writer, object, datatype, lang, FIELD_OBJECT, flags));
+    if (writer->syntax == SERD_NQUADS && graph) {
+      sink(" ", 1, writer);
+      TRY(write_node(writer, graph, datatype, lang, FIELD_GRAPH, flags));
+    }
+    sink(" .\n", 3, writer);
+    return SERD_SUCCESS;
+  }
+
+  if ((graph && !serd_node_equals(graph, &writer->context.graph)) ||
+      (!graph && writer->context.graph.type)) {
+    writer->indent = 0;
+
+    if (writer->context.subject.type) {
+      write_sep(writer, SEP_END_S);
+    }
+
+    if (writer->context.graph.type) {
+      write_sep(writer, SEP_GRAPH_END);
+    }
+
+    reset_context(writer, true);
+    if (graph) {
+      TRY(write_node(writer, graph, datatype, lang, FIELD_GRAPH, flags));
+      ++writer->indent;
+      write_sep(writer, SEP_GRAPH_BEGIN);
+      copy_node(&writer->context.graph, graph);
+    }
+  }
+
+  if ((flags & SERD_LIST_CONT)) {
+    if (write_list_obj(writer, flags, predicate, object, datatype, lang)) {
+      // Reached end of list
+      if (--writer->list_depth == 0 && writer->list_subj.type) {
+        reset_context(writer, false);
+        serd_node_free(&writer->context.subject);
+        writer->context.subject = writer->list_subj;
+        writer->list_subj       = SERD_NODE_NULL;
+      }
+      return SERD_SUCCESS;
+    }
+  } else if (serd_node_equals(subject, &writer->context.subject)) {
+    if (serd_node_equals(predicate, &writer->context.predicate)) {
+      // Abbreviate S P
+      if (!(flags & SERD_ANON_O_BEGIN)) {
+        ++writer->indent;
+      }
+      write_sep(writer, SEP_END_O);
+      write_node(writer, object, datatype, lang, FIELD_OBJECT, flags);
+      if (!(flags & SERD_ANON_O_BEGIN)) {
+        --writer->indent;
+      }
+    } else {
+      // Abbreviate S
+      Sep sep = writer->context.predicate.type ? SEP_END_P : SEP_S_P;
+      write_sep(writer, sep);
+      write_pred(writer, flags, predicate);
+      write_node(writer, object, datatype, lang, FIELD_OBJECT, flags);
+    }
+  } else {
+    // No abbreviation
+    if (writer->context.subject.type) {
+      assert(writer->indent > 0);
+      --writer->indent;
+      if (serd_stack_is_empty(&writer->anon_stack)) {
+        write_sep(writer, SEP_END_S);
+      }
+    } else if (!writer->empty) {
+      write_sep(writer, SEP_S_P);
+    }
+
+    if (!(flags & SERD_ANON_CONT)) {
+      write_node(writer, subject, NULL, NULL, FIELD_SUBJECT, flags);
+      ++writer->indent;
+      write_sep(writer, SEP_S_P);
+    } else {
+      ++writer->indent;
+    }
+
+    reset_context(writer, false);
+    copy_node(&writer->context.subject, subject);
+
+    if (!(flags & SERD_LIST_S_BEGIN)) {
+      write_pred(writer, flags, predicate);
+    }
+
+    write_node(writer, object, datatype, lang, FIELD_OBJECT, flags);
+  }
+
+  if (flags & (SERD_ANON_S_BEGIN | SERD_ANON_O_BEGIN)) {
+    WriteContext* ctx =
+      (WriteContext*)serd_stack_push(&writer->anon_stack, sizeof(WriteContext));
+    *ctx                     = writer->context;
+    WriteContext new_context = {
+      serd_node_copy(graph), serd_node_copy(subject), SERD_NODE_NULL};
+    if ((flags & SERD_ANON_S_BEGIN)) {
+      new_context.predicate = serd_node_copy(predicate);
+    }
+    writer->context = new_context;
+  } else {
+    copy_node(&writer->context.graph, graph);
+    copy_node(&writer->context.subject, subject);
+    copy_node(&writer->context.predicate, predicate);
+  }
+
+  return SERD_SUCCESS;
 }
 
 SerdStatus
-serd_writer_end_anon(SerdWriter*     writer,
-                     const SerdNode* node)
+serd_writer_end_anon(SerdWriter* writer, const SerdNode* node)
 {
-	if (writer->syntax == SERD_NTRIPLES || writer->syntax == SERD_NQUADS) {
-		return SERD_SUCCESS;
-	}
-	if (serd_stack_is_empty(&writer->anon_stack) || writer->indent == 0) {
-		w_err(writer, SERD_ERR_UNKNOWN,
-		      "unexpected end of anonymous node\n");
-		return SERD_ERR_UNKNOWN;
-	}
-	--writer->indent;
-	write_sep(writer, SEP_ANON_END);
-	free_context(writer);
-	writer->context = *anon_stack_top(writer);
-	serd_stack_pop(&writer->anon_stack, sizeof(WriteContext));
-	const bool is_subject = serd_node_equals(node, &writer->context.subject);
-	if (is_subject) {
-		copy_node(&writer->context.subject, node);
-		writer->context.predicate.type = SERD_NOTHING;
-	}
-	return SERD_SUCCESS;
+  if (writer->syntax == SERD_NTRIPLES || writer->syntax == SERD_NQUADS) {
+    return SERD_SUCCESS;
+  }
+
+  if (serd_stack_is_empty(&writer->anon_stack) || writer->indent == 0) {
+    w_err(writer, SERD_ERR_UNKNOWN, "unexpected end of anonymous node\n");
+    return SERD_ERR_UNKNOWN;
+  }
+
+  --writer->indent;
+  write_sep(writer, SEP_ANON_END);
+  free_context(writer);
+  writer->context = *anon_stack_top(writer);
+  serd_stack_pop(&writer->anon_stack, sizeof(WriteContext));
+  const bool is_subject = serd_node_equals(node, &writer->context.subject);
+  if (is_subject) {
+    copy_node(&writer->context.subject, node);
+    writer->context.predicate.type = SERD_NOTHING;
+  }
+
+  return SERD_SUCCESS;
 }
 
 SerdStatus
 serd_writer_finish(SerdWriter* writer)
 {
-	if (writer->context.subject.type) {
-		write_sep(writer, SEP_END_S);
-	}
-	if (writer->context.graph.type) {
-		write_sep(writer, SEP_GRAPH_END);
-	}
-	serd_byte_sink_flush(&writer->byte_sink);
-	writer->indent = 0;
-	return free_context(writer);
+  if (writer->context.subject.type) {
+    write_sep(writer, SEP_END_S);
+  }
+
+  if (writer->context.graph.type) {
+    write_sep(writer, SEP_GRAPH_END);
+  }
+
+  serd_byte_sink_flush(&writer->byte_sink);
+  writer->indent = 0;
+  return free_context(writer);
 }
 
 SerdWriter*
@@ -905,21 +964,23 @@ serd_writer_new(SerdSyntax     syntax,
                 SerdSink       ssink,
                 void*          stream)
 {
-	const WriteContext context = WRITE_CONTEXT_NULL;
-	SerdWriter*        writer  = (SerdWriter*)calloc(1, sizeof(SerdWriter));
-	writer->syntax       = syntax;
-	writer->style        = style;
-	writer->env          = env;
-	writer->root_node    = SERD_NODE_NULL;
-	writer->root_uri     = SERD_URI_NULL;
-	writer->base_uri     = base_uri ? *base_uri : SERD_URI_NULL;
-	writer->anon_stack   = serd_stack_new(4 * sizeof(WriteContext));
-	writer->context      = context;
-	writer->list_subj    = SERD_NODE_NULL;
-	writer->empty        = true;
-	writer->byte_sink    = serd_byte_sink_new(
-		ssink, stream, (style & SERD_STYLE_BULK) ? SERD_PAGE_SIZE : 1);
-	return writer;
+  const WriteContext context = WRITE_CONTEXT_NULL;
+  SerdWriter*        writer  = (SerdWriter*)calloc(1, sizeof(SerdWriter));
+
+  writer->syntax     = syntax;
+  writer->style      = style;
+  writer->env        = env;
+  writer->root_node  = SERD_NODE_NULL;
+  writer->root_uri   = SERD_URI_NULL;
+  writer->base_uri   = base_uri ? *base_uri : SERD_URI_NULL;
+  writer->anon_stack = serd_stack_new(4 * sizeof(WriteContext));
+  writer->context    = context;
+  writer->list_subj  = SERD_NODE_NULL;
+  writer->empty      = true;
+  writer->byte_sink  = serd_byte_sink_new(
+    ssink, stream, (style & SERD_STYLE_BULK) ? SERD_PAGE_SIZE : 1);
+
+  return writer;
 }
 
 void
@@ -927,60 +988,61 @@ serd_writer_set_error_sink(SerdWriter*   writer,
                            SerdErrorSink error_sink,
                            void*         error_handle)
 {
-	writer->error_sink   = error_sink;
-	writer->error_handle = error_handle;
+  writer->error_sink   = error_sink;
+  writer->error_handle = error_handle;
 }
 
 void
 serd_writer_chop_blank_prefix(SerdWriter* writer, const uint8_t* prefix)
 {
-	free(writer->bprefix);
-	writer->bprefix_len = 0;
-	writer->bprefix     = NULL;
-
-	const size_t prefix_len = prefix ? strlen((const char*)prefix) : 0;
-	if (prefix_len) {
-		writer->bprefix_len = prefix_len;
-		writer->bprefix     = (uint8_t*)malloc(writer->bprefix_len + 1);
-		memcpy(writer->bprefix, prefix, writer->bprefix_len + 1);
-	}
+  free(writer->bprefix);
+  writer->bprefix_len = 0;
+  writer->bprefix     = NULL;
+
+  const size_t prefix_len = prefix ? strlen((const char*)prefix) : 0;
+  if (prefix_len) {
+    writer->bprefix_len = prefix_len;
+    writer->bprefix     = (uint8_t*)malloc(writer->bprefix_len + 1);
+    memcpy(writer->bprefix, prefix, writer->bprefix_len + 1);
+  }
 }
 
 SerdStatus
-serd_writer_set_base_uri(SerdWriter*     writer,
-                         const SerdNode* uri)
+serd_writer_set_base_uri(SerdWriter* writer, const SerdNode* uri)
 {
-	if (!serd_env_set_base_uri(writer->env, uri)) {
-		serd_env_get_base_uri(writer->env, &writer->base_uri);
-
-		if (writer->syntax == SERD_TURTLE || writer->syntax == SERD_TRIG) {
-			if (writer->context.graph.type || writer->context.subject.type) {
-				sink(" .\n\n", 4, writer);
-				reset_context(writer, true);
-			}
-			sink("@base <", 7, writer);
-			sink(uri->buf, uri->n_bytes, writer);
-			sink("> .\n", 4, writer);
-		}
-		writer->indent = 0;
-		return reset_context(writer, true);
-	}
-	return SERD_ERR_UNKNOWN;
+  if (!serd_env_set_base_uri(writer->env, uri)) {
+    serd_env_get_base_uri(writer->env, &writer->base_uri);
+
+    if (writer->syntax == SERD_TURTLE || writer->syntax == SERD_TRIG) {
+      if (writer->context.graph.type || writer->context.subject.type) {
+        sink(" .\n\n", 4, writer);
+        reset_context(writer, true);
+      }
+      sink("@base <", 7, writer);
+      sink(uri->buf, uri->n_bytes, writer);
+      sink("> .\n", 4, writer);
+    }
+    writer->indent = 0;
+    return reset_context(writer, true);
+  }
+
+  return SERD_ERR_UNKNOWN;
 }
 
 SerdStatus
-serd_writer_set_root_uri(SerdWriter*     writer,
-                         const SerdNode* uri)
+serd_writer_set_root_uri(SerdWriter* writer, const SerdNode* uri)
 {
-	serd_node_free(&writer->root_node);
-	if (uri && uri->buf) {
-		writer->root_node = serd_node_copy(uri);
-		serd_uri_parse(uri->buf, &writer->root_uri);
-	} else {
-		writer->root_node = SERD_NODE_NULL;
-		writer->root_uri  = SERD_URI_NULL;
-	}
-	return SERD_SUCCESS;
+  serd_node_free(&writer->root_node);
+
+  if (uri && uri->buf) {
+    writer->root_node = serd_node_copy(uri);
+    serd_uri_parse(uri->buf, &writer->root_uri);
+  } else {
+    writer->root_node = SERD_NODE_NULL;
+    writer->root_uri  = SERD_URI_NULL;
+  }
+
+  return SERD_SUCCESS;
 }
 
 SerdStatus
@@ -988,64 +1050,65 @@ serd_writer_set_prefix(SerdWriter*     writer,
                        const SerdNode* name,
                        const SerdNode* uri)
 {
-	if (!serd_env_set_prefix(writer->env, name, uri)) {
-		if (writer->syntax == SERD_TURTLE || writer->syntax == SERD_TRIG) {
-			if (writer->context.graph.type || writer->context.subject.type) {
-				sink(" .\n\n", 4, writer);
-				reset_context(writer, true);
-			}
-			sink("@prefix ", 8, writer);
-			sink(name->buf, name->n_bytes, writer);
-			sink(": <", 3, writer);
-			write_uri(writer, uri->buf, uri->n_bytes);
-			sink("> .\n", 4, writer);
-		}
-		writer->indent = 0;
-		return reset_context(writer, true);
-	}
-	return SERD_ERR_UNKNOWN;
+  if (!serd_env_set_prefix(writer->env, name, uri)) {
+    if (writer->syntax == SERD_TURTLE || writer->syntax == SERD_TRIG) {
+      if (writer->context.graph.type || writer->context.subject.type) {
+        sink(" .\n\n", 4, writer);
+        reset_context(writer, true);
+      }
+      sink("@prefix ", 8, writer);
+      sink(name->buf, name->n_bytes, writer);
+      sink(": <", 3, writer);
+      write_uri(writer, uri->buf, uri->n_bytes);
+      sink("> .\n", 4, writer);
+    }
+    writer->indent = 0;
+    return reset_context(writer, true);
+  }
+
+  return SERD_ERR_UNKNOWN;
 }
 
 void
 serd_writer_free(SerdWriter* writer)
 {
-	if (!writer) {
-		return;
-	}
-
-	serd_writer_finish(writer);
-	serd_stack_free(&writer->anon_stack);
-	free(writer->bprefix);
-	serd_byte_sink_free(&writer->byte_sink);
-	serd_node_free(&writer->root_node);
-	free(writer);
+  if (!writer) {
+    return;
+  }
+
+  serd_writer_finish(writer);
+  serd_stack_free(&writer->anon_stack);
+  free(writer->bprefix);
+  serd_byte_sink_free(&writer->byte_sink);
+  serd_node_free(&writer->root_node);
+  free(writer);
 }
 
 SerdEnv*
 serd_writer_get_env(SerdWriter* writer)
 {
-	return writer->env;
+  return writer->env;
 }
 
 size_t
 serd_file_sink(const void* buf, size_t len, void* stream)
 {
-	return fwrite(buf, 1, len, (FILE*)stream);
+  return fwrite(buf, 1, len, (FILE*)stream);
 }
 
 size_t
 serd_chunk_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;
-	return len;
+  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;
+  return len;
 }
 
 uint8_t*
 serd_chunk_sink_finish(SerdChunk* stream)
 {
-	serd_chunk_sink("", 1, stream);
-	return (uint8_t*)stream->buf;
+  serd_chunk_sink("", 1, stream);
+  return (uint8_t*)stream->buf;
 }
diff --git a/test/test_env.c b/test/test_env.c
index 36b8f6c3..2fa9d3b5 100644
--- a/test/test_env.c
+++ b/test/test_env.c
@@ -27,74 +27,76 @@
 static SerdStatus
 count_prefixes(void* handle, const SerdNode* name, const SerdNode* uri)
 {
-	(void)name;
-	(void)uri;
+  (void)name;
+  (void)uri;
 
-	++*(int*)handle;
-	return SERD_SUCCESS;
+  ++*(int*)handle;
+  return SERD_SUCCESS;
 }
 
 static void
 test_env(void)
 {
-	SerdNode u   = serd_node_from_string(SERD_URI, USTR("http://example.org/foo"));
-	SerdNode b   = serd_node_from_string(SERD_CURIE, USTR("invalid"));
-	SerdNode c   = serd_node_from_string(SERD_CURIE, USTR("eg.2:b"));
-	SerdEnv* env = serd_env_new(NULL);
-	serd_env_set_prefix_from_strings(env, USTR("eg.2"), USTR("http://example.org/"));
+  SerdNode u = serd_node_from_string(SERD_URI, USTR("http://example.org/foo"));
+  SerdNode b = serd_node_from_string(SERD_CURIE, USTR("invalid"));
+  SerdNode c = serd_node_from_string(SERD_CURIE, USTR("eg.2:b"));
+  SerdEnv* env = serd_env_new(NULL);
+  serd_env_set_prefix_from_strings(
+    env, USTR("eg.2"), USTR("http://example.org/"));
 
-	assert(!serd_env_set_base_uri(env, NULL));
-	assert(serd_env_set_base_uri(env, &SERD_NODE_NULL));
-	assert(serd_node_equals(serd_env_get_base_uri(env, NULL), &SERD_NODE_NULL));
+  assert(!serd_env_set_base_uri(env, NULL));
+  assert(serd_env_set_base_uri(env, &SERD_NODE_NULL));
+  assert(serd_node_equals(serd_env_get_base_uri(env, NULL), &SERD_NODE_NULL));
 
-	SerdChunk prefix;
-	SerdChunk suffix;
-	assert(serd_env_expand(env, &b, &prefix, &suffix));
+  SerdChunk prefix;
+  SerdChunk suffix;
+  assert(serd_env_expand(env, &b, &prefix, &suffix));
 
-	SerdNode xnode = serd_env_expand_node(env, &SERD_NODE_NULL);
-	assert(serd_node_equals(&xnode, &SERD_NODE_NULL));
+  SerdNode xnode = serd_env_expand_node(env, &SERD_NODE_NULL);
+  assert(serd_node_equals(&xnode, &SERD_NODE_NULL));
 
-	SerdNode xu = serd_env_expand_node(env, &u);
-	assert(!strcmp((const char*)xu.buf, "http://example.org/foo"));
-	serd_node_free(&xu);
+  SerdNode xu = serd_env_expand_node(env, &u);
+  assert(!strcmp((const char*)xu.buf, "http://example.org/foo"));
+  serd_node_free(&xu);
 
-	SerdNode badpre = serd_node_from_string(SERD_CURIE, USTR("hm:what"));
-	SerdNode xbadpre = serd_env_expand_node(env, &badpre);
-	assert(serd_node_equals(&xbadpre, &SERD_NODE_NULL));
+  SerdNode badpre  = serd_node_from_string(SERD_CURIE, USTR("hm:what"));
+  SerdNode xbadpre = serd_env_expand_node(env, &badpre);
+  assert(serd_node_equals(&xbadpre, &SERD_NODE_NULL));
 
-	SerdNode xc = serd_env_expand_node(env, &c);
-	assert(!strcmp((const char*)xc.buf, "http://example.org/b"));
-	serd_node_free(&xc);
+  SerdNode xc = serd_env_expand_node(env, &c);
+  assert(!strcmp((const char*)xc.buf, "http://example.org/b"));
+  serd_node_free(&xc);
 
-	assert(serd_env_set_prefix(env, &SERD_NODE_NULL, &SERD_NODE_NULL));
+  assert(serd_env_set_prefix(env, &SERD_NODE_NULL, &SERD_NODE_NULL));
 
-	const SerdNode lit = serd_node_from_string(SERD_LITERAL, USTR("hello"));
-	assert(serd_env_set_prefix(env, &b, &lit));
+  const SerdNode lit = serd_node_from_string(SERD_LITERAL, USTR("hello"));
+  assert(serd_env_set_prefix(env, &b, &lit));
 
-	const SerdNode blank  = serd_node_from_string(SERD_BLANK, USTR("b1"));
-	const SerdNode xblank = serd_env_expand_node(env, &blank);
-	assert(serd_node_equals(&xblank, &SERD_NODE_NULL));
+  const SerdNode blank  = serd_node_from_string(SERD_BLANK, USTR("b1"));
+  const SerdNode xblank = serd_env_expand_node(env, &blank);
+  assert(serd_node_equals(&xblank, &SERD_NODE_NULL));
 
-	int n_prefixes = 0;
-	serd_env_set_prefix_from_strings(env, USTR("eg.2"), USTR("http://example.org/"));
-	serd_env_foreach(env, count_prefixes, &n_prefixes);
-	assert(n_prefixes == 1);
+  int n_prefixes = 0;
+  serd_env_set_prefix_from_strings(
+    env, USTR("eg.2"), USTR("http://example.org/"));
+  serd_env_foreach(env, count_prefixes, &n_prefixes);
+  assert(n_prefixes == 1);
 
-	SerdNode shorter_uri = serd_node_from_string(SERD_URI, USTR("urn:foo"));
-	SerdNode prefix_name;
-	assert(!serd_env_qualify(env, &shorter_uri, &prefix_name, &suffix));
+  SerdNode shorter_uri = serd_node_from_string(SERD_URI, USTR("urn:foo"));
+  SerdNode prefix_name;
+  assert(!serd_env_qualify(env, &shorter_uri, &prefix_name, &suffix));
 
-	assert(!serd_env_set_base_uri(env, &u));
-	assert(serd_node_equals(serd_env_get_base_uri(env, NULL), &u));
-	assert(!serd_env_set_base_uri(env, NULL));
-	assert(!serd_env_get_base_uri(env, NULL)->buf);
+  assert(!serd_env_set_base_uri(env, &u));
+  assert(serd_node_equals(serd_env_get_base_uri(env, NULL), &u));
+  assert(!serd_env_set_base_uri(env, NULL));
+  assert(!serd_env_get_base_uri(env, NULL)->buf);
 
-	serd_env_free(env);
+  serd_env_free(env);
 }
 
 int
 main(void)
 {
-	test_env();
-	return 0;
+  test_env();
+  return 0;
 }
diff --git a/test/test_free_null.c b/test/test_free_null.c
index 121a66cd..a544a005 100644
--- a/test/test_free_null.c
+++ b/test/test_free_null.c
@@ -23,11 +23,11 @@
 int
 main(void)
 {
-	serd_free(NULL);
-	serd_node_free(NULL);
-	serd_env_free(NULL);
-	serd_reader_free(NULL);
-	serd_writer_free(NULL);
+  serd_free(NULL);
+  serd_node_free(NULL);
+  serd_env_free(NULL);
+  serd_reader_free(NULL);
+  serd_writer_free(NULL);
 
-	return 0;
+  return 0;
 }
diff --git a/test/test_node.c b/test/test_node.c
index 45c40aa4..f65a7c22 100644
--- a/test/test_node.c
+++ b/test/test_node.c
@@ -30,174 +30,183 @@
 #define USTR(s) ((const uint8_t*)(s))
 
 #ifndef INFINITY
-#    define INFINITY (DBL_MAX + DBL_MAX)
+#  define INFINITY (DBL_MAX + DBL_MAX)
 #endif
 #ifndef NAN
-#    define NAN (INFINITY - INFINITY)
+#  define NAN (INFINITY - INFINITY)
 #endif
 
 static void
 test_strtod(double dbl, double max_delta)
 {
-	char buf[1024];
-	snprintf(buf, sizeof(buf), "%f", dbl);
+  char buf[1024];
+  snprintf(buf, sizeof(buf), "%f", dbl);
 
-	char* endptr = NULL;
-	const double out = serd_strtod(buf, &endptr);
+  char*        endptr = NULL;
+  const double out    = serd_strtod(buf, &endptr);
+  const double diff   = fabs(out - dbl);
 
-	const double diff = fabs(out - dbl);
-	assert(diff <= max_delta);
+  assert(diff <= max_delta);
 }
 
 static void
 test_string_to_double(void)
 {
-	const double expt_test_nums[] = {
-		2.0E18, -5e19, +8e20, 2e+24, -5e-5, 8e0, 9e-0, 2e+0
-	};
+  const double expt_test_nums[] = {
+    2.0E18, -5e19, +8e20, 2e+24, -5e-5, 8e0, 9e-0, 2e+0};
 
-	const char* expt_test_strs[] = {
-		"02e18", "-5e019", "+8e20", "2E+24", "-5E-5", "8E0", "9e-0", " 2e+0"
-	};
+  const char* expt_test_strs[] = {
+    "02e18", "-5e019", "+8e20", "2E+24", "-5E-5", "8E0", "9e-0", " 2e+0"};
 
-	for (size_t i = 0; i < sizeof(expt_test_nums) / sizeof(double); ++i) {
-		const double num   = serd_strtod(expt_test_strs[i], NULL);
-		const double delta = fabs(num - expt_test_nums[i]);
-		assert(delta <= DBL_EPSILON);
+  for (size_t i = 0; i < sizeof(expt_test_nums) / sizeof(double); ++i) {
+    const double num   = serd_strtod(expt_test_strs[i], NULL);
+    const double delta = fabs(num - expt_test_nums[i]);
+    assert(delta <= DBL_EPSILON);
 
-		test_strtod(expt_test_nums[i], DBL_EPSILON);
-	}
+    test_strtod(expt_test_nums[i], DBL_EPSILON);
+  }
 }
 
 static void
 test_double_to_node(void)
 {
-	const double dbl_test_nums[] = {
-		0.0, 9.0, 10.0, .01, 2.05, -16.00001, 5.000000005, 0.0000000001, NAN, INFINITY
-	};
-
-	const char* dbl_test_strs[] = {
-		"0.0", "9.0", "10.0", "0.01", "2.05", "-16.00001", "5.00000001", "0.0", NULL, NULL
-	};
-
-	for (size_t i = 0; i < sizeof(dbl_test_nums) / sizeof(double); ++i) {
-		SerdNode   node = serd_node_new_decimal(dbl_test_nums[i], 8);
-		const bool pass = (node.buf && dbl_test_strs[i])
-			? !strcmp((const char*)node.buf, dbl_test_strs[i])
-			: ((const char*)node.buf == dbl_test_strs[i]);
-		assert(pass);
-		const size_t len = node.buf ? strlen((const char*)node.buf) : 0;
-		assert(node.n_bytes == len && node.n_chars == len);
-		serd_node_free(&node);
-	}
+  const double dbl_test_nums[] = {0.0,
+                                  9.0,
+                                  10.0,
+                                  .01,
+                                  2.05,
+                                  -16.00001,
+                                  5.000000005,
+                                  0.0000000001,
+                                  NAN,
+                                  INFINITY};
+
+  const char* dbl_test_strs[] = {"0.0",
+                                 "9.0",
+                                 "10.0",
+                                 "0.01",
+                                 "2.05",
+                                 "-16.00001",
+                                 "5.00000001",
+                                 "0.0",
+                                 NULL,
+                                 NULL};
+
+  for (size_t i = 0; i < sizeof(dbl_test_nums) / sizeof(double); ++i) {
+    SerdNode   node = serd_node_new_decimal(dbl_test_nums[i], 8);
+    const bool pass = (node.buf && dbl_test_strs[i])
+                        ? !strcmp((const char*)node.buf, dbl_test_strs[i])
+                        : ((const char*)node.buf == dbl_test_strs[i]);
+    assert(pass);
+    const size_t len = node.buf ? strlen((const char*)node.buf) : 0;
+    assert(node.n_bytes == len && node.n_chars == len);
+    serd_node_free(&node);
+  }
 }
 
 static void
 test_integer_to_node(void)
 {
-	const long int_test_nums[] = {
-		0, -0, -23, 23, -12340, 1000, -1000
-	};
-
-	const char* int_test_strs[] = {
-		"0", "0", "-23", "23", "-12340", "1000", "-1000"
-	};
-
-	for (size_t i = 0; i < sizeof(int_test_nums) / sizeof(double); ++i) {
-		SerdNode node = serd_node_new_integer(int_test_nums[i]);
-		assert(!strcmp((const char*)node.buf, (const char*)int_test_strs[i]));
-		const size_t len = strlen((const char*)node.buf);
-		assert(node.n_bytes == len && node.n_chars == len);
-		serd_node_free(&node);
-	}
+  const long int_test_nums[] = {0, -0, -23, 23, -12340, 1000, -1000};
+
+  const char* int_test_strs[] = {
+    "0", "0", "-23", "23", "-12340", "1000", "-1000"};
+
+  for (size_t i = 0; i < sizeof(int_test_nums) / sizeof(double); ++i) {
+    SerdNode node = serd_node_new_integer(int_test_nums[i]);
+    assert(!strcmp((const char*)node.buf, (const char*)int_test_strs[i]));
+    const size_t len = strlen((const char*)node.buf);
+    assert(node.n_bytes == len && node.n_chars == len);
+    serd_node_free(&node);
+  }
 }
 
 static void
 test_blob_to_node(void)
 {
-	for (size_t size = 1; size < 256; ++size) {
-		uint8_t* const data = (uint8_t*)malloc(size);
-		for (size_t i = 0; i < size; ++i) {
-			data[i] = (uint8_t)((size + i) % 256);
-		}
-
-		SerdNode blob = serd_node_new_blob(data, size, size % 5);
-
-		assert(blob.n_bytes == blob.n_chars);
-		assert(blob.n_bytes == strlen((const char*)blob.buf));
-
-		size_t   out_size = 0;
-		uint8_t* out = (uint8_t*)serd_base64_decode(
-			blob.buf, blob.n_bytes, &out_size);
-		assert(out_size == size);
-
-		for (size_t i = 0; i < size; ++i) {
-			assert(out[i] == data[i]);
-		}
-
-		serd_node_free(&blob);
-		serd_free(out);
-		free(data);
-	}
+  for (size_t size = 1; size < 256; ++size) {
+    uint8_t* const data = (uint8_t*)malloc(size);
+    for (size_t i = 0; i < size; ++i) {
+      data[i] = (uint8_t)((size + i) % 256);
+    }
+
+    SerdNode blob = serd_node_new_blob(data, size, size % 5);
+
+    assert(blob.n_bytes == blob.n_chars);
+    assert(blob.n_bytes == strlen((const char*)blob.buf));
+
+    size_t   out_size = 0;
+    uint8_t* out =
+      (uint8_t*)serd_base64_decode(blob.buf, blob.n_bytes, &out_size);
+    assert(out_size == size);
+
+    for (size_t i = 0; i < size; ++i) {
+      assert(out[i] == data[i]);
+    }
+
+    serd_node_free(&blob);
+    serd_free(out);
+    free(data);
+  }
 }
 
 static void
 test_node_equals(void)
 {
-	const uint8_t replacement_char_str[] = { 0xEF, 0xBF, 0xBD, 0 };
-	SerdNode lhs = serd_node_from_string(SERD_LITERAL, replacement_char_str);
-	SerdNode rhs = serd_node_from_string(SERD_LITERAL, USTR("123"));
-	assert(!serd_node_equals(&lhs, &rhs));
+  const uint8_t replacement_char_str[] = {0xEF, 0xBF, 0xBD, 0};
+  SerdNode      lhs = serd_node_from_string(SERD_LITERAL, replacement_char_str);
+  SerdNode      rhs = serd_node_from_string(SERD_LITERAL, USTR("123"));
+  assert(!serd_node_equals(&lhs, &rhs));
 
-	SerdNode qnode = serd_node_from_string(SERD_CURIE, USTR("foo:bar"));
-	assert(!serd_node_equals(&lhs, &qnode));
-	assert(serd_node_equals(&lhs, &lhs));
+  SerdNode qnode = serd_node_from_string(SERD_CURIE, USTR("foo:bar"));
+  assert(!serd_node_equals(&lhs, &qnode));
+  assert(serd_node_equals(&lhs, &lhs));
 
-	SerdNode null_copy = serd_node_copy(&SERD_NODE_NULL);
-	assert(serd_node_equals(&SERD_NODE_NULL, &null_copy));
+  SerdNode null_copy = serd_node_copy(&SERD_NODE_NULL);
+  assert(serd_node_equals(&SERD_NODE_NULL, &null_copy));
 }
 
 static void
 test_node_from_string(void)
 {
-	SerdNode node = serd_node_from_string(SERD_LITERAL, (const uint8_t*)"hello\"");
-	assert(node.n_bytes == 6 && node.n_chars == 6 &&
-	       node.flags == SERD_HAS_QUOTE &&
-	       !strcmp((const char*)node.buf, "hello\""));
+  SerdNode node =
+    serd_node_from_string(SERD_LITERAL, (const uint8_t*)"hello\"");
 
-	node = serd_node_from_string(SERD_URI, NULL);
-	assert(serd_node_equals(&node, &SERD_NODE_NULL));
+  assert(node.n_bytes == 6 && node.n_chars == 6 &&
+         node.flags == SERD_HAS_QUOTE &&
+         !strcmp((const char*)node.buf, "hello\""));
+
+  node = serd_node_from_string(SERD_URI, NULL);
+  assert(serd_node_equals(&node, &SERD_NODE_NULL));
 }
 
 static void
 test_node_from_substring(void)
 {
-	SerdNode empty = serd_node_from_substring(SERD_LITERAL, NULL, 32);
-	assert(!empty.buf && !empty.n_bytes && !empty.n_chars && !empty.flags &&
-	       !empty.type);
-
-	SerdNode a_b = serd_node_from_substring(SERD_LITERAL, USTR("a\"bc"), 3);
-	assert(a_b.n_bytes == 3 && a_b.n_chars == 3 &&
-	       a_b.flags == SERD_HAS_QUOTE &&
-	       !strncmp((const char*)a_b.buf, "a\"b", 3));
-
-	a_b = serd_node_from_substring(SERD_LITERAL, USTR("a\"bc"), 10);
-	assert(a_b.n_bytes == 4 && a_b.n_chars == 4 &&
-	       a_b.flags == SERD_HAS_QUOTE &&
-	       !strncmp((const char*)a_b.buf, "a\"bc", 4));
+  SerdNode empty = serd_node_from_substring(SERD_LITERAL, NULL, 32);
+  assert(!empty.buf && !empty.n_bytes && !empty.n_chars && !empty.flags &&
+         !empty.type);
+
+  SerdNode a_b = serd_node_from_substring(SERD_LITERAL, USTR("a\"bc"), 3);
+  assert(a_b.n_bytes == 3 && a_b.n_chars == 3 && a_b.flags == SERD_HAS_QUOTE &&
+         !strncmp((const char*)a_b.buf, "a\"b", 3));
+
+  a_b = serd_node_from_substring(SERD_LITERAL, USTR("a\"bc"), 10);
+  assert(a_b.n_bytes == 4 && a_b.n_chars == 4 && a_b.flags == SERD_HAS_QUOTE &&
+         !strncmp((const char*)a_b.buf, "a\"bc", 4));
 }
 
 int
 main(void)
 {
-	test_string_to_double();
-	test_double_to_node();
-	test_integer_to_node();
-	test_blob_to_node();
-	test_node_equals();
-	test_node_from_string();
-	test_node_from_substring();
-
-	printf("Success\n");
-	return 0;
+  test_string_to_double();
+  test_double_to_node();
+  test_integer_to_node();
+  test_blob_to_node();
+  test_node_equals();
+  test_node_from_string();
+  test_node_from_substring();
+
+  printf("Success\n");
+  return 0;
 }
diff --git a/test/test_read_chunk.c b/test/test_read_chunk.c
index cc9c2e19..2e7f2b0d 100644
--- a/test/test_read_chunk.c
+++ b/test/test_read_chunk.c
@@ -30,22 +30,22 @@ static size_t n_end       = 0;
 static SerdStatus
 on_base(void* handle, const SerdNode* uri)
 {
-	(void)handle;
-	(void)uri;
+  (void)handle;
+  (void)uri;
 
-	++n_base;
-	return SERD_SUCCESS;
+  ++n_base;
+  return SERD_SUCCESS;
 }
 
 static SerdStatus
 on_prefix(void* handle, const SerdNode* name, const SerdNode* uri)
 {
-	(void)handle;
-	(void)name;
-	(void)uri;
+  (void)handle;
+  (void)name;
+  (void)uri;
 
-	++n_prefix;
-	return SERD_SUCCESS;
+  ++n_prefix;
+  return SERD_SUCCESS;
 }
 
 static SerdStatus
@@ -58,64 +58,65 @@ on_statement(void*              handle,
              const SerdNode*    object_datatype,
              const SerdNode*    object_lang)
 {
-	(void)handle;
-	(void)flags;
-	(void)graph;
-	(void)subject;
-	(void)predicate;
-	(void)object;
-	(void)object_datatype;
-	(void)object_lang;
-
-	++n_statement;
-	return SERD_SUCCESS;
+  (void)handle;
+  (void)flags;
+  (void)graph;
+  (void)subject;
+  (void)predicate;
+  (void)object;
+  (void)object_datatype;
+  (void)object_lang;
+
+  ++n_statement;
+  return SERD_SUCCESS;
 }
 
 static SerdStatus
 on_end(void* handle, const SerdNode* node)
 {
-	(void)handle;
-	(void)node;
+  (void)handle;
+  (void)node;
 
-	++n_end;
-	return SERD_SUCCESS;
+  ++n_end;
+  return SERD_SUCCESS;
 }
 
 int
 main(void)
 {
-	FILE* file = tmpfile();
-
-	fprintf(file,
-	        "@prefix eg: <http://example.org/> .\n"
-	        "@base <http://example.org/base> .\n"
-	        "eg:s1 eg:p1 eg:o1 ;\n"
-	        "      eg:p2 eg:o2 ,\n"
-	        "            eg:o3 .\n"
-	        "eg:s2 eg:p1 eg:o1 ;\n"
-	        "      eg:p2 eg:o2 .\n"
-	        "eg:s3 eg:p1 eg:o1 .\n"
-	        "eg:s4 eg:p1 [ eg:p3 eg:o1 ] .\n");
-
-	fseek(file, 0, SEEK_SET);
-
-	SerdReader* reader = serd_reader_new(
-	    SERD_TURTLE, NULL, NULL, on_base, on_prefix, on_statement, on_end);
-	assert(reader);
-
-	assert(!serd_reader_start_stream(reader, file, NULL, true));
-
-	assert(!serd_reader_read_chunk(reader) && n_prefix == 1);
-	assert(!serd_reader_read_chunk(reader) && n_base == 1);
-	assert(!serd_reader_read_chunk(reader) && n_statement == 3);
-	assert(!serd_reader_read_chunk(reader) && n_statement == 5);
-	assert(!serd_reader_read_chunk(reader) && n_statement == 6);
-	assert(!serd_reader_read_chunk(reader) && n_statement == 8 && n_end == 1);
-	assert(serd_reader_read_chunk(reader) == SERD_FAILURE);
-	assert(serd_reader_read_chunk(reader) == SERD_FAILURE);
-	assert(!serd_reader_end_stream(reader));
-
-	serd_reader_free(reader);
-	fclose(file);
-	return 0;
+  FILE* file = tmpfile();
+
+  fprintf(file,
+          "@prefix eg: <http://example.org/> .\n"
+          "@base <http://example.org/base> .\n"
+          "eg:s1 eg:p1 eg:o1 ;\n"
+          "      eg:p2 eg:o2 ,\n"
+          "            eg:o3 .\n"
+          "eg:s2 eg:p1 eg:o1 ;\n"
+          "      eg:p2 eg:o2 .\n"
+          "eg:s3 eg:p1 eg:o1 .\n"
+          "eg:s4 eg:p1 [ eg:p3 eg:o1 ] .\n");
+
+  fseek(file, 0, SEEK_SET);
+
+  SerdReader* reader = serd_reader_new(
+    SERD_TURTLE, NULL, NULL, on_base, on_prefix, on_statement, on_end);
+
+  assert(reader);
+  assert(!serd_reader_start_stream(reader, file, NULL, true));
+
+  assert(!serd_reader_read_chunk(reader) && n_prefix == 1);
+  assert(!serd_reader_read_chunk(reader) && n_base == 1);
+  assert(!serd_reader_read_chunk(reader) && n_statement == 3);
+  assert(!serd_reader_read_chunk(reader) && n_statement == 5);
+  assert(!serd_reader_read_chunk(reader) && n_statement == 6);
+  assert(!serd_reader_read_chunk(reader) && n_statement == 8 && n_end == 1);
+  assert(serd_reader_read_chunk(reader) == SERD_FAILURE);
+  assert(serd_reader_read_chunk(reader) == SERD_FAILURE);
+
+  assert(!serd_reader_end_stream(reader));
+  serd_reader_free(reader);
+  fclose(file);
+
+  return 0;
 }
diff --git a/test/test_reader_writer.c b/test/test_reader_writer.c
index 22576f72..d47bcccc 100644
--- a/test/test_reader_writer.c
+++ b/test/test_reader_writer.c
@@ -28,8 +28,8 @@
 #define USTR(s) ((const uint8_t*)(s))
 
 typedef struct {
-	int             n_statements;
-	const SerdNode* graph;
+  int             n_statements;
+  const SerdNode* graph;
 } ReaderTest;
 
 static SerdStatus
@@ -42,315 +42,322 @@ test_sink(void*              handle,
           const SerdNode*    object_datatype,
           const SerdNode*    object_lang)
 {
-	(void)flags;
-	(void)subject;
-	(void)predicate;
-	(void)object;
-	(void)object_datatype;
-	(void)object_lang;
-
-	ReaderTest* rt = (ReaderTest*)handle;
-	++rt->n_statements;
-	rt->graph = graph;
-	return SERD_SUCCESS;
+  (void)flags;
+  (void)subject;
+  (void)predicate;
+  (void)object;
+  (void)object_datatype;
+  (void)object_lang;
+
+  ReaderTest* rt = (ReaderTest*)handle;
+  ++rt->n_statements;
+  rt->graph = graph;
+  return SERD_SUCCESS;
 }
 
 /// Returns EOF after a statement, then succeeds again (like a socket)
 static size_t
 eof_test_read(void* buf, size_t size, size_t nmemb, void* stream)
 {
-	assert(nmemb == 1);
+  assert(nmemb == 1);
 
-	static const char* const string = "_:s1 <http://example.org/p> _:o1 .\n"
-	                                  "_:s2 <http://example.org/p> _:o2 .\n";
+  static const char* const string = "_:s1 <http://example.org/p> _:o1 .\n"
+                                    "_:s2 <http://example.org/p> _:o2 .\n";
 
-	size_t* count = (size_t*)stream;
-	if (*count == 34 || *count == 35 || *count + nmemb >= strlen(string)) {
-		++*count;
-		return 0;
-	}
+  size_t* count = (size_t*)stream;
+  if (*count == 34 || *count == 35 || *count + nmemb >= strlen(string)) {
+    ++*count;
+    return 0;
+  }
 
-	memcpy((char*)buf, string + *count, size * nmemb);
-	*count += nmemb;
-	return nmemb;
+  memcpy((char*)buf, string + *count, size * nmemb);
+  *count += nmemb;
+  return nmemb;
 }
 
 static int
 eof_test_error(void* stream)
 {
-	(void)stream;
-	return 0;
+  (void)stream;
+  return 0;
 }
 
 static void
 test_read_chunks(void)
 {
-	ReaderTest* const rt   = (ReaderTest*)calloc(1, sizeof(ReaderTest));
-	FILE* const       f    = tmpfile();
-	static const char null = 0;
-	SerdReader* const reader =
-	        serd_reader_new(SERD_TURTLE, rt, free, NULL, NULL, test_sink, NULL);
-
-	assert(reader);
-	assert(serd_reader_get_handle(reader) == rt);
-	assert(f);
-
-	SerdStatus st = serd_reader_start_stream(reader, f, NULL, false);
-	assert(st == SERD_SUCCESS);
-
-	// Write two statement separated by null characters
-	fprintf(f, "@prefix eg: <http://example.org/> .\n");
-	fprintf(f, "eg:s eg:p eg:o1 .\n");
-	fwrite(&null, sizeof(null), 1, f);
-	fprintf(f, "eg:s eg:p eg:o2 .\n");
-	fwrite(&null, sizeof(null), 1, f);
-	fseek(f, 0, SEEK_SET);
-
-	// Read prefix
-	st = serd_reader_read_chunk(reader);
-	assert(st == SERD_SUCCESS);
-	assert(rt->n_statements == 0);
-
-	// Read first statement
-	st = serd_reader_read_chunk(reader);
-	assert(st == SERD_SUCCESS);
-	assert(rt->n_statements == 1);
-
-	// Read terminator
-	st = serd_reader_read_chunk(reader);
-	assert(st == SERD_FAILURE);
-	assert(rt->n_statements == 1);
-
-	// Read second statement (after null terminator)
-	st = serd_reader_read_chunk(reader);
-	assert(st == SERD_SUCCESS);
-	assert(rt->n_statements == 2);
-
-	// Read terminator
-	st = serd_reader_read_chunk(reader);
-	assert(st == SERD_FAILURE);
-	assert(rt->n_statements == 2);
-
-	// EOF
-	st = serd_reader_read_chunk(reader);
-	assert(st == SERD_FAILURE);
-	assert(rt->n_statements == 2);
-
-	serd_reader_free(reader);
-	fclose(f);
+  ReaderTest* const rt   = (ReaderTest*)calloc(1, sizeof(ReaderTest));
+  FILE* const       f    = tmpfile();
+  static const char null = 0;
+  SerdReader* const reader =
+    serd_reader_new(SERD_TURTLE, rt, free, NULL, NULL, test_sink, NULL);
+
+  assert(reader);
+  assert(serd_reader_get_handle(reader) == rt);
+  assert(f);
+
+  SerdStatus st = serd_reader_start_stream(reader, f, NULL, false);
+  assert(st == SERD_SUCCESS);
+
+  // Write two statement separated by null characters
+  fprintf(f, "@prefix eg: <http://example.org/> .\n");
+  fprintf(f, "eg:s eg:p eg:o1 .\n");
+  fwrite(&null, sizeof(null), 1, f);
+  fprintf(f, "eg:s eg:p eg:o2 .\n");
+  fwrite(&null, sizeof(null), 1, f);
+  fseek(f, 0, SEEK_SET);
+
+  // Read prefix
+  st = serd_reader_read_chunk(reader);
+  assert(st == SERD_SUCCESS);
+  assert(rt->n_statements == 0);
+
+  // Read first statement
+  st = serd_reader_read_chunk(reader);
+  assert(st == SERD_SUCCESS);
+  assert(rt->n_statements == 1);
+
+  // Read terminator
+  st = serd_reader_read_chunk(reader);
+  assert(st == SERD_FAILURE);
+  assert(rt->n_statements == 1);
+
+  // Read second statement (after null terminator)
+  st = serd_reader_read_chunk(reader);
+  assert(st == SERD_SUCCESS);
+  assert(rt->n_statements == 2);
+
+  // Read terminator
+  st = serd_reader_read_chunk(reader);
+  assert(st == SERD_FAILURE);
+  assert(rt->n_statements == 2);
+
+  // EOF
+  st = serd_reader_read_chunk(reader);
+  assert(st == SERD_FAILURE);
+  assert(rt->n_statements == 2);
+
+  serd_reader_free(reader);
+  fclose(f);
 }
 
 static void
 test_read_string(void)
 {
-	ReaderTest* rt = (ReaderTest*)calloc(1, sizeof(ReaderTest));
-	SerdReader* reader =
-	    serd_reader_new(SERD_TURTLE, rt, free, NULL, NULL, test_sink, NULL);
+  ReaderTest* rt = (ReaderTest*)calloc(1, sizeof(ReaderTest));
+  SerdReader* reader =
+    serd_reader_new(SERD_TURTLE, rt, free, NULL, NULL, test_sink, NULL);
 
-	assert(reader);
-	assert(serd_reader_get_handle(reader) == rt);
+  assert(reader);
+  assert(serd_reader_get_handle(reader) == rt);
 
-	// Test reading a string that ends exactly at the end of input (no newline)
-	const SerdStatus st =
-		serd_reader_read_string(reader,
-		                        USTR("<http://example.org/s> <http://example.org/p> "
-		                             "<http://example.org/o> ."));
+  // Test reading a string that ends exactly at the end of input (no newline)
+  const SerdStatus st = serd_reader_read_string(
+    reader,
+    USTR("<http://example.org/s> <http://example.org/p> "
+         "<http://example.org/o> ."));
 
-	assert(!st);
-	assert(rt->n_statements == 1);
+  assert(!st);
+  assert(rt->n_statements == 1);
 
-	serd_reader_free(reader);
+  serd_reader_free(reader);
 }
 
 static void
 test_writer(const char* const path)
 {
-	FILE* fd = fopen(path, "wb");
-	SerdEnv* env = serd_env_new(NULL);
-	assert(fd);
-
-	SerdWriter* writer = serd_writer_new(
-		SERD_TURTLE, (SerdStyle)0, env, NULL, serd_file_sink, fd);
-	assert(writer);
-
-	serd_writer_chop_blank_prefix(writer, USTR("tmp"));
-	serd_writer_chop_blank_prefix(writer, NULL);
-
-	const SerdNode lit = serd_node_from_string(SERD_LITERAL, USTR("hello"));
-
-	assert(serd_writer_set_base_uri(writer, &lit));
-	assert(serd_writer_set_prefix(writer, &lit, &lit));
-	assert(serd_writer_end_anon(writer, NULL));
-	assert(serd_writer_get_env(writer) == env);
-
-	uint8_t buf[] = { 0x80, 0, 0, 0, 0 };
-	SerdNode s = serd_node_from_string(SERD_URI, USTR(""));
-	SerdNode p = serd_node_from_string(SERD_URI, USTR("http://example.org/pred"));
-	SerdNode o = serd_node_from_string(SERD_LITERAL, buf);
-
-	// Write 3 invalid statements (should write nothing)
-	const SerdNode* junk[][5] = { { &s, &p, &SERD_NODE_NULL, NULL, NULL },
-	                              { &s, &SERD_NODE_NULL, &o, NULL, NULL },
-	                              { &SERD_NODE_NULL, &p, &o, NULL, NULL },
-	                              { &s, &o, &o, NULL, NULL },
-	                              { &o, &p, &o, NULL, NULL },
-	                              { &s, &p, &SERD_NODE_NULL, NULL, NULL } };
-	for (size_t i = 0; i < sizeof(junk) / (sizeof(SerdNode*) * 5); ++i) {
-		assert(serd_writer_write_statement(
-			       writer, 0, NULL,
-			       junk[i][0], junk[i][1], junk[i][2], junk[i][3], junk[i][4]));
-	}
-
-	const SerdNode t = serd_node_from_string(SERD_URI, USTR("urn:Type"));
-	const SerdNode l = serd_node_from_string(SERD_LITERAL, USTR("en"));
-	const SerdNode* good[][5] = { { &s, &p, &o, NULL, NULL },
-	                              { &s, &p, &o, &SERD_NODE_NULL, &SERD_NODE_NULL },
-	                              { &s, &p, &o, &t, NULL },
-	                              { &s, &p, &o, NULL, &l },
-	                              { &s, &p, &o, &t, &l },
-	                              { &s, &p, &o, &t, &SERD_NODE_NULL },
-	                              { &s, &p, &o, &SERD_NODE_NULL, &l },
-	                              { &s, &p, &o, NULL, &SERD_NODE_NULL },
-	                              { &s, &p, &o, &SERD_NODE_NULL, NULL },
-	                              { &s, &p, &o, &SERD_NODE_NULL, NULL } };
-	for (size_t i = 0; i < sizeof(good) / (sizeof(SerdNode*) * 5); ++i) {
-		assert(!serd_writer_write_statement(
-			       writer, 0, NULL,
-			       good[i][0], good[i][1], good[i][2], good[i][3], good[i][4]));
-	}
-
-	// Write statements with bad UTF-8 (should be replaced)
-	const uint8_t bad_str[] = { 0xFF, 0x90, 'h', 'i', 0 };
-	SerdNode      bad_lit   = serd_node_from_string(SERD_LITERAL, bad_str);
-	SerdNode      bad_uri   = serd_node_from_string(SERD_URI, bad_str);
-	assert(!serd_writer_write_statement(writer, 0, NULL,
-	                                    &s, &p, &bad_lit, NULL, NULL));
-	assert(!serd_writer_write_statement(writer, 0, NULL,
-	                                    &s, &p, &bad_uri, NULL, NULL));
-
-	// Write 1 valid statement
-	o = serd_node_from_string(SERD_LITERAL, USTR("hello"));
-	assert(!serd_writer_write_statement(writer, 0, NULL,
-	                                    &s, &p, &o, NULL, NULL));
-
-	serd_writer_free(writer);
-
-	// Test chunk sink
-	SerdChunk chunk = { NULL, 0 };
-	writer = serd_writer_new(
-		SERD_TURTLE, (SerdStyle)0, env, NULL, serd_chunk_sink, &chunk);
-
-	o = serd_node_from_string(SERD_URI, USTR("http://example.org/base"));
-	assert(!serd_writer_set_base_uri(writer, &o));
-
-	serd_writer_free(writer);
-	uint8_t* out = serd_chunk_sink_finish(&chunk);
-
-	assert(!strcmp((const char*)out, "@base <http://example.org/base> .\n"));
-	serd_free(out);
-
-	// Test writing empty node
-	SerdNode    nothing = serd_node_from_string(SERD_NOTHING, USTR(""));
-	FILE* const empty   = tmpfile();
-
-	writer = serd_writer_new(
-		SERD_TURTLE, (SerdStyle)0, env, NULL, serd_file_sink, empty);
-
-	// FIXME: error handling
-	serd_writer_write_statement(writer, 0, NULL,
-	                            &s, &p, &nothing, NULL, NULL);
-
-	assert((size_t)ftell(empty) == strlen("<>\n\t<http://example.org/pred> "));
-
-	serd_writer_free(writer);
-	fclose(empty);
-
-	serd_env_free(env);
-	fclose(fd);
+  FILE*    fd  = fopen(path, "wb");
+  SerdEnv* env = serd_env_new(NULL);
+  assert(fd);
+
+  SerdWriter* writer =
+    serd_writer_new(SERD_TURTLE, (SerdStyle)0, env, NULL, serd_file_sink, fd);
+  assert(writer);
+
+  serd_writer_chop_blank_prefix(writer, USTR("tmp"));
+  serd_writer_chop_blank_prefix(writer, NULL);
+
+  const SerdNode lit = serd_node_from_string(SERD_LITERAL, USTR("hello"));
+
+  assert(serd_writer_set_base_uri(writer, &lit));
+  assert(serd_writer_set_prefix(writer, &lit, &lit));
+  assert(serd_writer_end_anon(writer, NULL));
+  assert(serd_writer_get_env(writer) == env);
+
+  uint8_t  buf[] = {0x80, 0, 0, 0, 0};
+  SerdNode s     = serd_node_from_string(SERD_URI, USTR(""));
+  SerdNode p = serd_node_from_string(SERD_URI, USTR("http://example.org/pred"));
+  SerdNode o = serd_node_from_string(SERD_LITERAL, buf);
+
+  // Write 3 invalid statements (should write nothing)
+  const SerdNode* junk[][5] = {{&s, &p, &SERD_NODE_NULL, NULL, NULL},
+                               {&s, &SERD_NODE_NULL, &o, NULL, NULL},
+                               {&SERD_NODE_NULL, &p, &o, NULL, NULL},
+                               {&s, &o, &o, NULL, NULL},
+                               {&o, &p, &o, NULL, NULL},
+                               {&s, &p, &SERD_NODE_NULL, NULL, NULL}};
+  for (size_t i = 0; i < sizeof(junk) / (sizeof(SerdNode*) * 5); ++i) {
+    assert(serd_writer_write_statement(writer,
+                                       0,
+                                       NULL,
+                                       junk[i][0],
+                                       junk[i][1],
+                                       junk[i][2],
+                                       junk[i][3],
+                                       junk[i][4]));
+  }
+
+  const SerdNode  t         = serd_node_from_string(SERD_URI, USTR("urn:Type"));
+  const SerdNode  l         = serd_node_from_string(SERD_LITERAL, USTR("en"));
+  const SerdNode* good[][5] = {{&s, &p, &o, NULL, NULL},
+                               {&s, &p, &o, &SERD_NODE_NULL, &SERD_NODE_NULL},
+                               {&s, &p, &o, &t, NULL},
+                               {&s, &p, &o, NULL, &l},
+                               {&s, &p, &o, &t, &l},
+                               {&s, &p, &o, &t, &SERD_NODE_NULL},
+                               {&s, &p, &o, &SERD_NODE_NULL, &l},
+                               {&s, &p, &o, NULL, &SERD_NODE_NULL},
+                               {&s, &p, &o, &SERD_NODE_NULL, NULL},
+                               {&s, &p, &o, &SERD_NODE_NULL, NULL}};
+  for (size_t i = 0; i < sizeof(good) / (sizeof(SerdNode*) * 5); ++i) {
+    assert(!serd_writer_write_statement(writer,
+                                        0,
+                                        NULL,
+                                        good[i][0],
+                                        good[i][1],
+                                        good[i][2],
+                                        good[i][3],
+                                        good[i][4]));
+  }
+
+  // Write statements with bad UTF-8 (should be replaced)
+  const uint8_t bad_str[] = {0xFF, 0x90, 'h', 'i', 0};
+  SerdNode      bad_lit   = serd_node_from_string(SERD_LITERAL, bad_str);
+  SerdNode      bad_uri   = serd_node_from_string(SERD_URI, bad_str);
+  assert(!serd_writer_write_statement(
+    writer, 0, NULL, &s, &p, &bad_lit, NULL, NULL));
+  assert(!serd_writer_write_statement(
+    writer, 0, NULL, &s, &p, &bad_uri, NULL, NULL));
+
+  // Write 1 valid statement
+  o = serd_node_from_string(SERD_LITERAL, USTR("hello"));
+  assert(!serd_writer_write_statement(writer, 0, NULL, &s, &p, &o, NULL, NULL));
+
+  serd_writer_free(writer);
+
+  // Test chunk sink
+  SerdChunk chunk = {NULL, 0};
+  writer          = serd_writer_new(
+    SERD_TURTLE, (SerdStyle)0, env, NULL, serd_chunk_sink, &chunk);
+
+  o = serd_node_from_string(SERD_URI, USTR("http://example.org/base"));
+  assert(!serd_writer_set_base_uri(writer, &o));
+
+  serd_writer_free(writer);
+  uint8_t* out = serd_chunk_sink_finish(&chunk);
+
+  assert(!strcmp((const char*)out, "@base <http://example.org/base> .\n"));
+  serd_free(out);
+
+  // Test writing empty node
+  SerdNode    nothing = serd_node_from_string(SERD_NOTHING, USTR(""));
+  FILE* const empty   = tmpfile();
+
+  writer = serd_writer_new(
+    SERD_TURTLE, (SerdStyle)0, env, NULL, serd_file_sink, empty);
+
+  // FIXME: error handling
+  serd_writer_write_statement(writer, 0, NULL, &s, &p, &nothing, NULL, NULL);
+
+  assert((size_t)ftell(empty) == strlen("<>\n\t<http://example.org/pred> "));
+
+  serd_writer_free(writer);
+  fclose(empty);
+
+  serd_env_free(env);
+  fclose(fd);
 }
 
 static void
 test_reader(const char* path)
 {
-	ReaderTest* rt     = (ReaderTest*)calloc(1, sizeof(ReaderTest));
-	SerdReader* reader = serd_reader_new(
-		SERD_TURTLE, rt, free,
-		NULL, NULL, test_sink, NULL);
-	assert(reader);
-	assert(serd_reader_get_handle(reader) == rt);
+  ReaderTest* rt = (ReaderTest*)calloc(1, sizeof(ReaderTest));
+  SerdReader* reader =
+    serd_reader_new(SERD_TURTLE, rt, free, NULL, NULL, test_sink, NULL);
+  assert(reader);
+  assert(serd_reader_get_handle(reader) == rt);
 
-	SerdNode g = serd_node_from_string(SERD_URI, USTR("http://example.org/"));
-	serd_reader_set_default_graph(reader, &g);
-	serd_reader_add_blank_prefix(reader, USTR("tmp"));
+  SerdNode g = serd_node_from_string(SERD_URI, USTR("http://example.org/"));
+  serd_reader_set_default_graph(reader, &g);
+  serd_reader_add_blank_prefix(reader, USTR("tmp"));
 
 #if defined(__GNUC__)
-#	pragma GCC diagnostic push
-#	pragma GCC diagnostic ignored "-Wnonnull"
+#  pragma GCC diagnostic push
+#  pragma GCC diagnostic ignored "-Wnonnull"
 #endif
-	serd_reader_add_blank_prefix(reader, NULL);
+  serd_reader_add_blank_prefix(reader, NULL);
 #if defined(__GNUC__)
-#	pragma GCC diagnostic pop
+#  pragma GCC diagnostic pop
 #endif
 
-	assert(serd_reader_read_file(reader, USTR("http://notafile")));
-	assert(serd_reader_read_file(reader, USTR("file:///better/not/exist")));
-	assert(serd_reader_read_file(reader, USTR("file://")));
-
-	const SerdStatus st = serd_reader_read_file(reader, USTR(path));
-	assert(!st);
-	assert(rt->n_statements == 13);
-	assert(rt->graph && rt->graph->buf &&
-	       !strcmp((const char*)rt->graph->buf, "http://example.org/"));
-
-	assert(serd_reader_read_string(reader, USTR("This isn't Turtle at all.")));
-
-	// A read of a big page hits EOF then fails to read chunks immediately
-	{
-		FILE* temp = tmpfile();
-		assert(temp);
-		fprintf(temp, "_:s <http://example.org/p> _:o .\n");
-		fflush(temp);
-		fseek(temp, 0L, SEEK_SET);
-
-		serd_reader_start_stream(reader, temp, NULL, true);
-
-		assert(serd_reader_read_chunk(reader) == SERD_SUCCESS);
-		assert(serd_reader_read_chunk(reader) == SERD_FAILURE);
-		assert(serd_reader_read_chunk(reader) == SERD_FAILURE);
-
-		serd_reader_end_stream(reader);
-		fclose(temp);
-	}
-
-	// A byte-wise reader that hits EOF once then continues (like a socket)
-	{
-		size_t n_reads = 0;
-		serd_reader_start_source_stream(reader,
-		                                (SerdSource)eof_test_read,
-		                                (SerdStreamErrorFunc)eof_test_error,
-		                                &n_reads,
-		                                NULL,
-		                                1);
-
-		assert(serd_reader_read_chunk(reader) == SERD_SUCCESS);
-		assert(serd_reader_read_chunk(reader) == SERD_FAILURE);
-		assert(serd_reader_read_chunk(reader) == SERD_SUCCESS);
-		assert(serd_reader_read_chunk(reader) == SERD_FAILURE);
-	}
-
-	serd_reader_free(reader);
+  assert(serd_reader_read_file(reader, USTR("http://notafile")));
+  assert(serd_reader_read_file(reader, USTR("file:///better/not/exist")));
+  assert(serd_reader_read_file(reader, USTR("file://")));
+
+  const SerdStatus st = serd_reader_read_file(reader, USTR(path));
+  assert(!st);
+  assert(rt->n_statements == 13);
+  assert(rt->graph && rt->graph->buf &&
+         !strcmp((const char*)rt->graph->buf, "http://example.org/"));
+
+  assert(serd_reader_read_string(reader, USTR("This isn't Turtle at all.")));
+
+  // A read of a big page hits EOF then fails to read chunks immediately
+  {
+    FILE* temp = tmpfile();
+    assert(temp);
+    fprintf(temp, "_:s <http://example.org/p> _:o .\n");
+    fflush(temp);
+    fseek(temp, 0L, SEEK_SET);
+
+    serd_reader_start_stream(reader, temp, NULL, true);
+
+    assert(serd_reader_read_chunk(reader) == SERD_SUCCESS);
+    assert(serd_reader_read_chunk(reader) == SERD_FAILURE);
+    assert(serd_reader_read_chunk(reader) == SERD_FAILURE);
+
+    serd_reader_end_stream(reader);
+    fclose(temp);
+  }
+
+  // A byte-wise reader that hits EOF once then continues (like a socket)
+  {
+    size_t n_reads = 0;
+    serd_reader_start_source_stream(reader,
+                                    (SerdSource)eof_test_read,
+                                    (SerdStreamErrorFunc)eof_test_error,
+                                    &n_reads,
+                                    NULL,
+                                    1);
+
+    assert(serd_reader_read_chunk(reader) == SERD_SUCCESS);
+    assert(serd_reader_read_chunk(reader) == SERD_FAILURE);
+    assert(serd_reader_read_chunk(reader) == SERD_SUCCESS);
+    assert(serd_reader_read_chunk(reader) == SERD_FAILURE);
+  }
+
+  serd_reader_free(reader);
 }
 
 int
 main(void)
 {
-	test_read_chunks();
-	test_read_string();
+  test_read_chunks();
+  test_read_string();
 
-	const char* const path = "serd_test.ttl";
-	test_writer(path);
-	test_reader(path);
+  const char* const path = "serd_test.ttl";
+  test_writer(path);
+  test_reader(path);
 
-	printf("Success\n");
-	return 0;
+  printf("Success\n");
+  return 0;
 }
diff --git a/test/test_string.c b/test/test_string.c
index 1e11f5b4..225eca4f 100644
--- a/test/test_string.c
+++ b/test/test_string.c
@@ -26,39 +26,39 @@
 static void
 test_strlen(void)
 {
-	const uint8_t str[] = { '"', '5', 0xE2, 0x82, 0xAC, '"', '\n', 0 };
+  const uint8_t str[] = {'"', '5', 0xE2, 0x82, 0xAC, '"', '\n', 0};
 
-	size_t        n_bytes = 0;
-	SerdNodeFlags flags   = 0;
-	size_t        len     = serd_strlen(str, &n_bytes, &flags);
-	assert(len == 5 && n_bytes == 7 &&
-	       flags == (SERD_HAS_QUOTE | SERD_HAS_NEWLINE));
-	len = serd_strlen(str, NULL, &flags);
-	assert(len == 5);
+  size_t        n_bytes = 0;
+  SerdNodeFlags flags   = 0;
+  size_t        len     = serd_strlen(str, &n_bytes, &flags);
+  assert(len == 5 && n_bytes == 7 &&
+         flags == (SERD_HAS_QUOTE | SERD_HAS_NEWLINE));
+  len = serd_strlen(str, NULL, &flags);
+  assert(len == 5);
 
-	assert(serd_strlen(str, &n_bytes, NULL) == 5);
+  assert(serd_strlen(str, &n_bytes, NULL) == 5);
 }
 
 static void
 test_strerror(void)
 {
-	const uint8_t* msg = serd_strerror(SERD_SUCCESS);
-	assert(!strcmp((const char*)msg, "Success"));
-	for (int i = SERD_FAILURE; i <= SERD_ERR_INTERNAL; ++i) {
-		msg = serd_strerror((SerdStatus)i);
-		assert(strcmp((const char*)msg, "Success"));
-	}
+  const uint8_t* msg = serd_strerror(SERD_SUCCESS);
+  assert(!strcmp((const char*)msg, "Success"));
+  for (int i = SERD_FAILURE; i <= SERD_ERR_INTERNAL; ++i) {
+    msg = serd_strerror((SerdStatus)i);
+    assert(strcmp((const char*)msg, "Success"));
+  }
 
-	msg = serd_strerror((SerdStatus)-1);
-	assert(!strcmp((const char*)msg, "Unknown error"));
+  msg = serd_strerror((SerdStatus)-1);
+  assert(!strcmp((const char*)msg, "Unknown error"));
 }
 
 int
 main(void)
 {
-	test_strlen();
-	test_strerror();
+  test_strlen();
+  test_strerror();
 
-	printf("Success\n");
-	return 0;
+  printf("Success\n");
+  return 0;
 }
diff --git a/test/test_uri.c b/test/test_uri.c
index 9538ffb0..f910e1f0 100644
--- a/test/test_uri.c
+++ b/test/test_uri.c
@@ -33,151 +33,153 @@ test_file_uri(const char* hostname,
               const char* expected_uri,
               const char* expected_path)
 {
-	if (!expected_path) {
-		expected_path = path;
-	}
-
-	SerdNode node = serd_node_new_file_uri(
-		USTR(path), USTR(hostname), 0, escape);
-
-	uint8_t* out_hostname = NULL;
-	uint8_t* out_path     = serd_file_uri_parse(node.buf, &out_hostname);
-	assert(!strcmp((const char*)node.buf, expected_uri));
-	assert((hostname && out_hostname) || (!hostname && !out_hostname));
-	assert(!strcmp((const char*)out_path, (const char*)expected_path));
-
-	serd_free(out_path);
-	serd_free(out_hostname);
-	serd_node_free(&node);
+  if (!expected_path) {
+    expected_path = path;
+  }
+
+  SerdNode node = serd_node_new_file_uri(USTR(path), USTR(hostname), 0, escape);
+
+  uint8_t* out_hostname = NULL;
+  uint8_t* out_path     = serd_file_uri_parse(node.buf, &out_hostname);
+  assert(!strcmp((const char*)node.buf, expected_uri));
+  assert((hostname && out_hostname) || (!hostname && !out_hostname));
+  assert(!strcmp((const char*)out_path, (const char*)expected_path));
+
+  serd_free(out_path);
+  serd_free(out_hostname);
+  serd_node_free(&node);
 }
 
 #if defined(__GNUC__)
-#	pragma GCC diagnostic push
-#	pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#  pragma GCC diagnostic push
+#  pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 #endif
 
 static void
 test_uri_to_path(void)
 {
-	const uint8_t* uri = (const uint8_t*)"file:///home/user/foo.ttl";
-	assert(!strcmp((const char*)serd_uri_to_path(uri), "/home/user/foo.ttl"));
+  const uint8_t* uri = (const uint8_t*)"file:///home/user/foo.ttl";
+  assert(!strcmp((const char*)serd_uri_to_path(uri), "/home/user/foo.ttl"));
 
-	uri = (const uint8_t*)"file://localhost/home/user/foo.ttl";
-	assert(!strcmp((const char*)serd_uri_to_path(uri), "/home/user/foo.ttl"));
+  uri = (const uint8_t*)"file://localhost/home/user/foo.ttl";
+  assert(!strcmp((const char*)serd_uri_to_path(uri), "/home/user/foo.ttl"));
 
-	uri = (const uint8_t*)"file:illegal/file/uri";
-	assert(!serd_uri_to_path(uri));
+  uri = (const uint8_t*)"file:illegal/file/uri";
+  assert(!serd_uri_to_path(uri));
 
-	uri = (const uint8_t*)"file:///c:/awful/system";
-	assert(!strcmp((const char*)serd_uri_to_path(uri), "c:/awful/system"));
+  uri = (const uint8_t*)"file:///c:/awful/system";
+  assert(!strcmp((const char*)serd_uri_to_path(uri), "c:/awful/system"));
 
-	uri = (const uint8_t*)"file:///c:awful/system";
-	assert(!strcmp((const char*)serd_uri_to_path(uri), "/c:awful/system"));
+  uri = (const uint8_t*)"file:///c:awful/system";
+  assert(!strcmp((const char*)serd_uri_to_path(uri), "/c:awful/system"));
 
-	uri = (const uint8_t*)"file:///0/1";
-	assert(!strcmp((const char*)serd_uri_to_path(uri), "/0/1"));
+  uri = (const uint8_t*)"file:///0/1";
+  assert(!strcmp((const char*)serd_uri_to_path(uri), "/0/1"));
 
-	uri = (const uint8_t*)"C:\\Windows\\Sucks";
-	assert(!strcmp((const char*)serd_uri_to_path(uri), "C:\\Windows\\Sucks"));
+  uri = (const uint8_t*)"C:\\Windows\\Sucks";
+  assert(!strcmp((const char*)serd_uri_to_path(uri), "C:\\Windows\\Sucks"));
 
-	uri = (const uint8_t*)"C|/Windows/Sucks";
-	assert(!strcmp((const char*)serd_uri_to_path(uri), "C|/Windows/Sucks"));
+  uri = (const uint8_t*)"C|/Windows/Sucks";
+  assert(!strcmp((const char*)serd_uri_to_path(uri), "C|/Windows/Sucks"));
 
-	uri = (const uint8_t*)"http://example.org/path";
-	assert(!serd_uri_to_path(uri));
+  uri = (const uint8_t*)"http://example.org/path";
+  assert(!serd_uri_to_path(uri));
 }
 
 #if defined(__GNUC__)
-#	pragma GCC diagnostic pop
+#  pragma GCC diagnostic pop
 #endif
 
 static void
 test_uri_parsing(void)
 {
-	test_file_uri(NULL, "C:/My 100%", true,
-	              "file:///C:/My%20100%%", NULL);
-	test_file_uri("ahost", "C:\\Pointless Space", true,
-	              "file://ahost/C:/Pointless%20Space", "C:/Pointless Space");
-	test_file_uri(NULL, "/foo/bar", true,
-	              "file:///foo/bar", NULL);
-	test_file_uri("bhost", "/foo/bar", true,
-	              "file://bhost/foo/bar", NULL);
-	test_file_uri(NULL, "a/relative path", false,
-	              "a/relative path", NULL);
-	test_file_uri(NULL, "a/relative <path>", true,
-	              "a/relative%20%3Cpath%3E", NULL);
-
-	// Test tolerance of parsing junk URI escapes
-
-	uint8_t* out_path = serd_file_uri_parse(USTR("file:///foo/%0Xbar"), NULL);
-	assert(!strcmp((const char*)out_path, "/foo/bar"));
-	serd_free(out_path);
+  test_file_uri(NULL, "C:/My 100%", true, "file:///C:/My%20100%%", NULL);
+  test_file_uri("ahost",
+                "C:\\Pointless Space",
+                true,
+                "file://ahost/C:/Pointless%20Space",
+                "C:/Pointless Space");
+  test_file_uri(NULL, "/foo/bar", true, "file:///foo/bar", NULL);
+  test_file_uri("bhost", "/foo/bar", true, "file://bhost/foo/bar", NULL);
+  test_file_uri(NULL, "a/relative path", false, "a/relative path", NULL);
+  test_file_uri(
+    NULL, "a/relative <path>", true, "a/relative%20%3Cpath%3E", NULL);
+
+  // Test tolerance of parsing junk URI escapes
+
+  uint8_t* out_path = serd_file_uri_parse(USTR("file:///foo/%0Xbar"), NULL);
+  assert(!strcmp((const char*)out_path, "/foo/bar"));
+  serd_free(out_path);
 }
 
 static void
 test_uri_from_string(void)
 {
-	SerdNode nonsense = serd_node_new_uri_from_string(NULL, NULL, NULL);
-	assert(nonsense.type == SERD_NOTHING);
-
-	SerdURI base_uri;
-	SerdNode base = serd_node_new_uri_from_string(USTR("http://example.org/"),
-	                                              NULL, &base_uri);
-	SerdNode nil = serd_node_new_uri_from_string(NULL, &base_uri, NULL);
-	SerdNode nil2 = serd_node_new_uri_from_string(USTR(""), &base_uri, NULL);
-	assert(nil.type == SERD_URI);
-	assert(!strcmp((const char*)nil.buf, (const char*)base.buf));
-	assert(nil2.type == SERD_URI);
-	assert(!strcmp((const char*)nil2.buf, (const char*)base.buf));
-	serd_node_free(&nil);
-	serd_node_free(&nil2);
-
-	serd_node_free(&base);
+  SerdNode nonsense = serd_node_new_uri_from_string(NULL, NULL, NULL);
+  assert(nonsense.type == SERD_NOTHING);
+
+  SerdURI  base_uri;
+  SerdNode base =
+    serd_node_new_uri_from_string(USTR("http://example.org/"), NULL, &base_uri);
+  SerdNode nil  = serd_node_new_uri_from_string(NULL, &base_uri, NULL);
+  SerdNode nil2 = serd_node_new_uri_from_string(USTR(""), &base_uri, NULL);
+  assert(nil.type == SERD_URI);
+  assert(!strcmp((const char*)nil.buf, (const char*)base.buf));
+  assert(nil2.type == SERD_URI);
+  assert(!strcmp((const char*)nil2.buf, (const char*)base.buf));
+  serd_node_free(&nil);
+  serd_node_free(&nil2);
+
+  serd_node_free(&base);
 }
 
 static void
 test_relative_uri(void)
 {
-	SerdURI base_uri;
-	SerdNode base = serd_node_new_uri_from_string(USTR("http://example.org/"),
-	                                              NULL, &base_uri);
-
-	SerdNode abs = serd_node_from_string(SERD_URI, USTR("http://example.org/foo/bar"));
-	SerdURI  abs_uri;
-	serd_uri_parse(abs.buf, &abs_uri);
-
-	SerdURI  rel_uri;
-	SerdNode rel = serd_node_new_relative_uri(&abs_uri, &base_uri, NULL, &rel_uri);
-	assert(!strcmp((const char*)rel.buf, "/foo/bar"));
-
-	SerdNode up = serd_node_new_relative_uri(&base_uri, &abs_uri, NULL, NULL);
-	assert(!strcmp((const char*)up.buf, "../"));
-
-	SerdNode noup = serd_node_new_relative_uri(&base_uri, &abs_uri, &abs_uri, NULL);
-	assert(!strcmp((const char*)noup.buf, "http://example.org/"));
-
-	SerdNode x = serd_node_from_string(SERD_URI, USTR("http://example.org/foo/x"));
-	SerdURI  x_uri;
-	serd_uri_parse(x.buf, &x_uri);
-
-	SerdNode x_rel = serd_node_new_relative_uri(&x_uri, &abs_uri, &abs_uri, NULL);
-	assert(!strcmp((const char*)x_rel.buf, "x"));
-
-	serd_node_free(&x_rel);
-	serd_node_free(&noup);
-	serd_node_free(&up);
-	serd_node_free(&rel);
-	serd_node_free(&base);
+  SerdURI  base_uri;
+  SerdNode base =
+    serd_node_new_uri_from_string(USTR("http://example.org/"), NULL, &base_uri);
+
+  SerdNode abs =
+    serd_node_from_string(SERD_URI, USTR("http://example.org/foo/bar"));
+  SerdURI abs_uri;
+  serd_uri_parse(abs.buf, &abs_uri);
+
+  SerdURI  rel_uri;
+  SerdNode rel =
+    serd_node_new_relative_uri(&abs_uri, &base_uri, NULL, &rel_uri);
+  assert(!strcmp((const char*)rel.buf, "/foo/bar"));
+
+  SerdNode up = serd_node_new_relative_uri(&base_uri, &abs_uri, NULL, NULL);
+  assert(!strcmp((const char*)up.buf, "../"));
+
+  SerdNode noup =
+    serd_node_new_relative_uri(&base_uri, &abs_uri, &abs_uri, NULL);
+  assert(!strcmp((const char*)noup.buf, "http://example.org/"));
+
+  SerdNode x =
+    serd_node_from_string(SERD_URI, USTR("http://example.org/foo/x"));
+  SerdURI x_uri;
+  serd_uri_parse(x.buf, &x_uri);
+
+  SerdNode x_rel = serd_node_new_relative_uri(&x_uri, &abs_uri, &abs_uri, NULL);
+  assert(!strcmp((const char*)x_rel.buf, "x"));
+
+  serd_node_free(&x_rel);
+  serd_node_free(&noup);
+  serd_node_free(&up);
+  serd_node_free(&rel);
+  serd_node_free(&base);
 }
 
 int
 main(void)
 {
-	test_uri_to_path();
-	test_uri_parsing();
-	test_uri_from_string();
-	test_relative_uri();
+  test_uri_to_path();
+  test_uri_parsing();
+  test_uri_from_string();
+  test_relative_uri();
 
-	printf("Success\n");
-	return 0;
+  printf("Success\n");
+  return 0;
 }