Improve writer error handling

6 files changed, 198 insertions, 149 deletions

diff --git a/src/byte_sink.h b/src/byte_sink.h
index ed0f65b4..65b5eb12 100644
--- a/src/byte_sink.h
+++ b/src/byte_sink.h
@@ -33,13 +33,18 @@ serd_byte_sink_new(SerdSink sink, void* stream, size_t block_size)
   return bsink;
 }
 
-static inline void
+static inline SerdStatus
 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;
+    const size_t size  = bsink->size;
+    const size_t n_out = bsink->sink(bsink->buf, size, bsink->stream);
+    bsink->size        = 0;
+
+    return (n_out != size) ? SERD_ERR_BAD_WRITE : SERD_SUCCESS;
   }
+
+  return SERD_SUCCESS;
 }
 
 static inline void
diff --git a/src/n3.c b/src/n3.c
index 48a7aba0..38505ee2 100644
--- a/src/n3.c
+++ b/src/n3.c
@@ -6,6 +6,7 @@
 #include "serd_internal.h"
 #include "stack.h"
 #include "string_utils.h"
+#include "try.h"
 #include "uri_utils.h"
 
 #include "serd/serd.h"
@@ -27,13 +28,6 @@ _Pragma("clang diagnostic ignored \"-Wmissing-declarations\"")
 #  define SERD_FALLTHROUGH
 #endif
 
-#define TRY(st, exp)      \
-  do {                    \
-    if (((st) = (exp))) { \
-      return (st);        \
-    }                     \
-  } while (0)
-
 static bool
 fancy_syntax(const SerdReader* const reader)
 {
diff --git a/src/serd_config.h b/src/serd_config.h
index 76733ab4..2a2c9b27 100644
--- a/src/serd_config.h
+++ b/src/serd_config.h
@@ -36,7 +36,7 @@
 #define SERD_SRC_SERD_CONFIG_H
 
 // Define version unconditionally so a warning will catch a mismatch
-#define SERD_VERSION "0.31.0"
+#define SERD_VERSION "0.31.1"
 
 #if !defined(SERD_NO_DEFAULT_CONFIG)
 
diff --git a/src/string.c b/src/string.c
index 8b679bb6..07513739 100644
--- a/src/string.c
+++ b/src/string.c
@@ -37,6 +37,8 @@ serd_strerror(const SerdStatus status)
     return (const uint8_t*)"Invalid CURIE";
   case SERD_ERR_INTERNAL:
     return (const uint8_t*)"Internal error";
+  case SERD_ERR_BAD_WRITE:
+    return (const uint8_t*)"Error writing to file/stream";
   }
   return (const uint8_t*)"Unknown error"; // never reached
 }
diff --git a/src/try.h b/src/try.h
new file mode 100644
index 00000000..f49ae05f
--- /dev/null
+++ b/src/try.h
@@ -0,0 +1,21 @@
+// Copyright 2011-2023 David Robillard <d@drobilla.net>
+// SPDX-License-Identifier: ISC
+
+#ifndef SERD_SRC_TRY_H
+#define SERD_SRC_TRY_H
+
+#define TRY(st, exp)      \
+  do {                    \
+    if (((st) = (exp))) { \
+      return (st);        \
+    }                     \
+  } while (0)
+
+#define TRY_FAILING(st, exp)             \
+  do {                                   \
+    if (((st) = (exp)) > SERD_FAILURE) { \
+      return (st);                       \
+    }                                    \
+  } while (0)
+
+#endif // SERD_SRC_TRY_H
diff --git a/src/writer.c b/src/writer.c
index 01b8ba47..fcd0e1dc 100644
--- a/src/writer.c
+++ b/src/writer.c
@@ -1,10 +1,12 @@
 // Copyright 2011-2023 David Robillard <d@drobilla.net>
 // SPDX-License-Identifier: ISC
 
+#include "attributes.h"
 #include "byte_sink.h"
 #include "serd_internal.h"
 #include "stack.h"
 #include "string_utils.h"
+#include "try.h"
 #include "uri_utils.h"
 
 #include "serd/serd.h"
@@ -102,7 +104,7 @@ struct SerdWriterImpl {
 typedef enum { WRITE_STRING, WRITE_LONG_STRING } TextContext;
 typedef enum { RESET_GRAPH = 1U << 0U, RESET_INDENT = 1U << 1U } ResetFlag;
 
-static bool
+SERD_NODISCARD static SerdStatus
 write_node(SerdWriter*        writer,
            const SerdNode*    node,
            const SerdNode*    datatype,
@@ -130,7 +132,7 @@ deindent(SerdWriter* writer)
   }
 }
 
-static void
+static SerdStatus
 w_err(SerdWriter* writer, SerdStatus st, const char* fmt, ...)
 {
   /* TODO: This results in errors with no file information, which is not
@@ -144,6 +146,7 @@ w_err(SerdWriter* writer, SerdStatus st, const char* fmt, ...)
   const SerdError e = {st, (const uint8_t*)"", 0, 0, fmt, &args};
   serd_error(writer->error_sink, writer->error_handle, &e);
   va_end(args);
+  return st;
 }
 
 SERD_PURE_FUNC static WriteContext*
@@ -175,6 +178,12 @@ sink(const void* buf, size_t len, SerdWriter* writer)
   return serd_byte_sink_write(buf, len, &writer->byte_sink);
 }
 
+SERD_NODISCARD static inline SerdStatus
+esink(const void* buf, size_t len, SerdWriter* writer)
+{
+  return sink(buf, len, writer) == len ? SERD_SUCCESS : SERD_ERR_BAD_WRITE;
+}
+
 // Write a single character, as an escape for single byte characters
 // (Caller prints any single byte characters that don't need escaping)
 static size_t
@@ -436,37 +445,42 @@ uri_sink(const void* buf, size_t len, void* stream)
   return write_uri((SerdWriter*)stream, (const uint8_t*)buf, len);
 }
 
-static void
+SERD_NODISCARD static SerdStatus
 write_newline(SerdWriter* writer)
 {
-  sink("\n", 1, writer);
+  SerdStatus st = SERD_SUCCESS;
+
+  TRY(st, esink("\n", 1, writer));
   for (unsigned i = 0; i < writer->indent; ++i) {
-    sink("\t", 1, writer);
+    TRY(st, esink("\t", 1, writer));
   }
+
+  return st;
 }
 
-static bool
+SERD_NODISCARD static SerdStatus
 write_sep(SerdWriter* writer, const Sep sep)
 {
+  SerdStatus     st   = SERD_SUCCESS;
   const SepRule* rule = &rules[sep];
   if (rule->space_before) {
-    write_newline(writer);
+    TRY(st, write_newline(writer));
   }
 
   if (rule->str) {
-    sink(rule->str, rule->len, writer);
+    TRY(st, esink(rule->str, rule->len, writer));
   }
 
   if (rule->space_after_sep ||
       (writer->last_sep == SEP_NODE && rule->space_after_node)) {
-    write_newline(writer);
+    TRY(st, write_newline(writer));
   } else if (writer->last_sep && writer->last_sep != SEP_GRAPH_BEGIN &&
              rule->space_after_node) {
-    sink(" ", 1, writer);
+    TRY(st, esink(" ", 1, writer));
   }
 
   writer->last_sep = sep;
-  return true;
+  return st;
 }
 
 static SerdStatus
@@ -514,20 +528,21 @@ is_inline_start(const SerdWriter* writer, Field field, SerdStatementFlags flags)
            (field == FIELD_OBJECT && (flags & SERD_ANON_O_BEGIN))));
 }
 
-static bool
+SERD_NODISCARD static SerdStatus
 write_literal(SerdWriter*        writer,
               const SerdNode*    node,
               const SerdNode*    datatype,
               const SerdNode*    lang,
               SerdStatementFlags flags)
 {
+  SerdStatus st = SERD_SUCCESS;
+
   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;
+      return esink(node->buf, node->n_bytes, writer);
     }
 
     if (!strncmp(type_uri, NS_XSD, sizeof(NS_XSD) - 1) &&
@@ -538,29 +553,28 @@ write_literal(SerdWriter*        writer,
          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;
+      return esink(node->buf, node->n_bytes, writer);
     }
   }
 
   if (supports_abbrev(writer) &&
       (node->flags & (SERD_HAS_NEWLINE | SERD_HAS_QUOTE))) {
-    sink("\"\"\"", 3, writer);
+    TRY(st, esink("\"\"\"", 3, writer));
     write_text(writer, WRITE_LONG_STRING, node->buf, node->n_bytes);
-    sink("\"\"\"", 3, writer);
+    TRY(st, esink("\"\"\"", 3, writer));
   } else {
-    sink("\"", 1, writer);
+    TRY(st, esink("\"", 1, writer));
     write_text(writer, WRITE_STRING, node->buf, node->n_bytes);
-    sink("\"", 1, writer);
+    TRY(st, esink("\"", 1, writer));
   }
   if (lang && lang->buf) {
-    sink("@", 1, writer);
-    sink(lang->buf, lang->n_bytes, writer);
+    TRY(st, esink("@", 1, writer));
+    TRY(st, esink(lang->buf, lang->n_bytes, writer));
   } else if (datatype && datatype->buf) {
-    sink("^^", 2, writer);
+    TRY(st, esink("^^", 2, writer));
     return write_node(writer, datatype, NULL, NULL, FIELD_NONE, flags);
   }
-  return true;
+  return SERD_SUCCESS;
 }
 
 // Return true iff `buf` is a valid prefixed name prefix or suffix
@@ -577,30 +591,31 @@ is_name(const uint8_t* buf, const size_t len)
   return true;
 }
 
-static bool
+SERD_NODISCARD static SerdStatus
 write_uri_node(SerdWriter* const        writer,
                const SerdNode*          node,
                const Field              field,
                const SerdStatementFlags flags)
 {
-  SerdNode  prefix;
-  SerdChunk suffix;
+  SerdStatus st     = SERD_SUCCESS;
+  SerdNode   prefix = SERD_NODE_NULL;
+  SerdChunk  suffix = {NULL, 0U};
 
   if (is_inline_start(writer, field, flags)) {
     ++writer->indent;
-    write_sep(writer, SEP_ANON_BEGIN);
-    sink("== ", 3, writer);
+    TRY(st, write_sep(writer, SEP_ANON_BEGIN));
+    TRY(st, esink("== ", 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;
+      return esink("a", 1, writer);
     }
 
     if (!strcmp((const char*)node->buf, NS_RDF "nil")) {
-      return sink("()", 2, writer) == 2;
+      return esink("()", 2, writer);
     }
 
     if (has_scheme && (writer->style & SERD_STYLE_CURIED) &&
@@ -608,22 +623,21 @@ write_uri_node(SerdWriter* const        writer,
         is_name(prefix.buf, prefix.n_bytes) &&
         is_name(suffix.buf, suffix.len)) {
       write_uri(writer, prefix.buf, prefix.n_bytes);
-      sink(":", 1, writer);
+      TRY(st, esink(":", 1, writer));
       write_uri(writer, suffix.buf, suffix.len);
-      return true;
+      return SERD_SUCCESS;
     }
   }
 
   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;
+    return w_err(writer,
+                 SERD_ERR_BAD_ARG,
+                 "syntax does not support URI reference <%s>\n",
+                 node->buf);
   }
 
-  sink("<", 1, writer);
+  TRY(st, esink("<", 1, writer));
   if (writer->style & SERD_STYLE_RESOLVED) {
     SerdURI in_base_uri;
     SerdURI uri;
@@ -643,17 +657,17 @@ write_uri_node(SerdWriter* const        writer,
   } else {
     write_uri(writer, node->buf, node->n_bytes);
   }
-  sink(">", 1, writer);
+  TRY(st, esink(">", 1, writer));
 
   if (is_inline_start(writer, field, flags)) {
-    sink(" ;", 2, writer);
-    write_newline(writer);
+    TRY(st, esink(" ;", 2, writer));
+    TRY(st, write_newline(writer));
   }
 
-  return true;
+  return SERD_SUCCESS;
 }
 
-static bool
+SERD_NODISCARD static SerdStatus
 write_curie(SerdWriter* const        writer,
             const SerdNode*          node,
             const Field              field,
@@ -667,37 +681,38 @@ write_curie(SerdWriter* const        writer,
   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;
+      return w_err(writer, st, "undefined namespace prefix '%s'\n", node->buf);
     }
-    sink("<", 1, writer);
+    TRY(st, esink("<", 1, writer));
     write_uri(writer, prefix.buf, prefix.len);
     write_uri(writer, suffix.buf, suffix.len);
-    sink(">", 1, writer);
+    TRY(st, esink(">", 1, writer));
     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);
+      TRY(st, write_sep(writer, SEP_ANON_BEGIN));
+      TRY(st, esink("== ", 3, writer));
     }
     write_lname(writer, node->buf, node->n_bytes);
     if (is_inline_start(writer, field, flags)) {
-      sink(" ;", 2, writer);
-      write_newline(writer);
+      TRY(st, esink(" ;", 2, writer));
+      TRY(st, write_newline(writer));
     }
   }
 
-  return true;
+  return SERD_SUCCESS;
 }
 
-static bool
+SERD_NODISCARD static SerdStatus
 write_blank(SerdWriter* const        writer,
             const SerdNode*          node,
             const Field              field,
             const SerdStatementFlags flags)
 {
+  SerdStatus st = SERD_SUCCESS;
+
   if (supports_abbrev(writer)) {
     if (is_inline_start(writer, field, flags)) {
       ++writer->indent;
@@ -719,25 +734,26 @@ write_blank(SerdWriter* const        writer,
 
     if ((field == FIELD_SUBJECT && (flags & SERD_EMPTY_S)) ||
         (field == FIELD_OBJECT && (flags & SERD_EMPTY_O))) {
-      return sink("[]", 2, writer) == 2;
+      return esink("[]", 2, writer);
     }
   }
 
-  sink("_:", 2, writer);
+  TRY(st, esink("_:", 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);
+    TRY(st,
+        esink(node->buf + writer->bprefix_len,
+              node->n_bytes - writer->bprefix_len,
+              writer));
   } else {
-    sink(node->buf, node->n_bytes, writer);
+    TRY(st, esink(node->buf, node->n_bytes, writer));
   }
 
-  return true;
+  return st;
 }
 
-static bool
+SERD_NODISCARD static SerdStatus
 write_node(SerdWriter*        writer,
            const SerdNode*    node,
            const SerdNode*    datatype,
@@ -745,26 +761,26 @@ write_node(SerdWriter*        writer,
            Field              field,
            SerdStatementFlags flags)
 {
-  bool ret = false;
+  SerdStatus st = SERD_SUCCESS;
   switch (node->type) {
   case SERD_NOTHING:
     break;
   case SERD_LITERAL:
-    ret = write_literal(writer, node, datatype, lang, flags);
+    st = write_literal(writer, node, datatype, lang, flags);
     break;
   case SERD_URI:
-    ret = write_uri_node(writer, node, field, flags);
+    st = write_uri_node(writer, node, field, flags);
     break;
   case SERD_CURIE:
-    ret = write_curie(writer, node, field, flags);
+    st = write_curie(writer, node, field, flags);
     break;
   case SERD_BLANK:
-    ret = write_blank(writer, node, field, flags);
+    st = write_blank(writer, node, field, flags);
     break;
   }
 
   writer->last_sep = SEP_NODE;
-  return ret;
+  return st;
 }
 
 static bool
@@ -773,46 +789,56 @@ is_resource(const SerdNode* node)
   return node && node->buf && node->type > SERD_LITERAL;
 }
 
-static void
+SERD_NODISCARD static SerdStatus
 write_pred(SerdWriter* writer, SerdStatementFlags flags, const SerdNode* pred)
 {
-  write_node(writer, pred, NULL, NULL, FIELD_PREDICATE, flags);
-  write_sep(writer, SEP_P_O);
+  SerdStatus st = SERD_SUCCESS;
+
+  TRY(st, write_node(writer, pred, NULL, NULL, FIELD_PREDICATE, flags));
+  TRY(st, write_sep(writer, SEP_P_O));
+
   copy_node(&writer->context.predicate, pred);
+  return st;
 }
 
-static bool
-write_list_obj(SerdWriter*        writer,
-               SerdStatementFlags flags,
-               const SerdNode*    predicate,
-               const SerdNode*    object,
-               const SerdNode*    datatype,
-               const SerdNode*    lang)
+SERD_NODISCARD static SerdStatus
+write_list_next(SerdWriter*        writer,
+                SerdStatementFlags flags,
+                const SerdNode*    predicate,
+                const SerdNode*    object,
+                const SerdNode*    datatype,
+                const SerdNode*    lang)
 {
+  SerdStatus st = SERD_SUCCESS;
+
   if (!strcmp((const char*)object->buf, NS_RDF "nil")) {
     deindent(writer);
-    write_sep(writer, SEP_LIST_END);
-    return true;
+    TRY(st, write_sep(writer, SEP_LIST_END));
+    return SERD_FAILURE;
   }
 
   if (!strcmp((const char*)predicate->buf, NS_RDF "first")) {
-    write_sep(writer, SEP_LIST_SEP);
-    write_node(writer, object, datatype, lang, FIELD_OBJECT, flags);
+    TRY(st, write_sep(writer, SEP_LIST_SEP));
+    TRY(st, write_node(writer, object, datatype, lang, FIELD_OBJECT, flags));
   }
 
-  return false;
+  return st;
 }
 
-static void
+SERD_NODISCARD static SerdStatus
 terminate_context(SerdWriter* writer)
 {
+  SerdStatus st = SERD_SUCCESS;
+
   if (writer->context.subject.type) {
-    write_sep(writer, SEP_END_S);
+    TRY(st, write_sep(writer, SEP_END_S));
   }
 
   if (writer->context.graph.type) {
-    write_sep(writer, SEP_GRAPH_END);
+    TRY(st, write_sep(writer, SEP_GRAPH_END));
   }
+
+  return st;
 }
 
 SerdStatus
@@ -825,47 +851,45 @@ serd_writer_write_statement(SerdWriter*        writer,
                             const SerdNode*    datatype,
                             const SerdNode*    lang)
 {
+  SerdStatus st = 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));
+    TRY(st, write_node(writer, subject, NULL, NULL, FIELD_SUBJECT, flags));
+    TRY(st, esink(" ", 1, writer));
+    TRY(st, write_node(writer, predicate, NULL, NULL, FIELD_PREDICATE, flags));
+    TRY(st, esink(" ", 1, writer));
+    TRY(st, 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));
+      TRY(st, esink(" ", 1, writer));
+      TRY(st, write_node(writer, graph, datatype, lang, FIELD_GRAPH, flags));
     }
-    sink(" .\n", 3, writer);
+    TRY(st, esink(" .\n", 3, writer));
     return SERD_SUCCESS;
   }
 
   if ((graph && !serd_node_equals(graph, &writer->context.graph)) ||
       (!graph && writer->context.graph.type)) {
-    terminate_context(writer);
+    TRY(st, terminate_context(writer));
     reset_context(writer, RESET_GRAPH | RESET_INDENT);
     if (graph) {
-      write_newline(writer);
-      TRY(write_node(writer, graph, datatype, lang, FIELD_GRAPH, flags));
+      TRY(st, write_newline(writer));
+      TRY(st, write_node(writer, graph, datatype, lang, FIELD_GRAPH, flags));
       ++writer->indent;
-      write_sep(writer, SEP_GRAPH_BEGIN);
+      TRY(st, 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)) {
+    TRY_FAILING(
+      st, write_list_next(writer, flags, predicate, object, datatype, lang));
+
+    if (st == SERD_FAILURE) {
       // Reached end of list
       if (--writer->list_depth == 0 && writer->list_subj.type) {
         reset_context(writer, 0U);
@@ -875,44 +899,45 @@ serd_writer_write_statement(SerdWriter*        writer,
       }
       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);
+      TRY(st, write_sep(writer, SEP_END_O));
+      TRY(st, write_node(writer, object, datatype, lang, FIELD_OBJECT, flags));
       if (!(flags & SERD_ANON_O_BEGIN)) {
         deindent(writer);
       }
     } 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);
+      TRY(st, write_sep(writer, sep));
+      TRY(st, write_pred(writer, flags, predicate));
+      TRY(st, write_node(writer, object, datatype, lang, FIELD_OBJECT, flags));
     }
   } else {
     // No abbreviation
     if (writer->context.subject.type) {
       deindent(writer);
       if (serd_stack_is_empty(&writer->anon_stack)) {
-        write_sep(writer, SEP_END_S);
+        TRY(st, write_sep(writer, SEP_END_S));
       }
     }
 
     if (!(flags & SERD_ANON_CONT)) {
       if (writer->last_sep == SEP_END_S || writer->last_sep == SEP_END_DIRECT) {
-        write_newline(writer);
+        TRY(st, write_newline(writer));
       }
 
-      write_node(writer, subject, NULL, NULL, FIELD_SUBJECT, flags);
+      TRY(st, write_node(writer, subject, NULL, NULL, FIELD_SUBJECT, flags));
       if ((flags & SERD_ANON_S_BEGIN)) {
-        write_sep(writer, SEP_ANON_S_P);
+        TRY(st, write_sep(writer, SEP_ANON_S_P));
       } else {
         ++writer->indent;
-        write_sep(writer, SEP_S_P);
+        TRY(st, write_sep(writer, SEP_S_P));
       }
 
     } else {
@@ -923,10 +948,10 @@ serd_writer_write_statement(SerdWriter*        writer,
     copy_node(&writer->context.subject, subject);
 
     if (!(flags & SERD_LIST_S_BEGIN)) {
-      write_pred(writer, flags, predicate);
+      TRY(st, write_pred(writer, flags, predicate));
     }
 
-    write_node(writer, object, datatype, lang, FIELD_OBJECT, flags);
+    TRY(st, write_node(writer, object, datatype, lang, FIELD_OBJECT, flags));
   }
 
   if (flags & (SERD_ANON_S_BEGIN | SERD_ANON_O_BEGIN)) {
@@ -951,17 +976,19 @@ serd_writer_write_statement(SerdWriter*        writer,
 SerdStatus
 serd_writer_end_anon(SerdWriter* writer, const SerdNode* node)
 {
+  SerdStatus st = 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;
+    return w_err(
+      writer, SERD_ERR_UNKNOWN, "unexpected end of anonymous node\n");
   }
 
   deindent(writer);
-  write_sep(writer, SEP_ANON_END);
+  TRY(st, write_sep(writer, SEP_ANON_END));
   free_context(&writer->context);
   writer->context = *anon_stack_top(writer);
   serd_stack_pop(&writer->anon_stack, sizeof(WriteContext));
@@ -971,18 +998,18 @@ serd_writer_end_anon(SerdWriter* writer, const SerdNode* node)
     writer->context.predicate.type = SERD_NOTHING;
   }
 
-  return SERD_SUCCESS;
+  return st;
 }
 
 SerdStatus
 serd_writer_finish(SerdWriter* writer)
 {
-  terminate_context(writer);
-  serd_byte_sink_flush(&writer->byte_sink);
+  const SerdStatus st0 = terminate_context(writer);
+  const SerdStatus st1 = serd_byte_sink_flush(&writer->byte_sink);
   free_context(&writer->context);
   writer->indent  = 0;
   writer->context = WRITE_CONTEXT_NULL;
-  return SERD_SUCCESS;
+  return st0 ? st0 : st1;
 }
 
 SerdWriter*
@@ -1038,7 +1065,7 @@ serd_writer_chop_blank_prefix(SerdWriter* writer, const uint8_t* prefix)
 SerdStatus
 serd_writer_set_base_uri(SerdWriter* writer, const SerdNode* uri)
 {
-  const SerdStatus st = serd_env_set_base_uri(writer->env, uri);
+  SerdStatus st = serd_env_set_base_uri(writer->env, uri);
   if (st) {
     return st;
   }
@@ -1046,12 +1073,12 @@ serd_writer_set_base_uri(SerdWriter* writer, const SerdNode* uri)
   serd_env_get_base_uri(writer->env, &writer->base_uri);
 
   if (writer->syntax == SERD_TURTLE || writer->syntax == SERD_TRIG) {
-    terminate_context(writer);
-    sink("@base <", 7, writer);
-    sink(uri->buf, uri->n_bytes, writer);
-    sink(">", 1, writer);
+    TRY(st, terminate_context(writer));
+    TRY(st, esink("@base <", 7, writer));
+    TRY(st, esink(uri->buf, uri->n_bytes, writer));
+    TRY(st, esink(">", 1, writer));
     writer->last_sep = SEP_NODE;
-    write_sep(writer, SEP_END_DIRECT);
+    TRY(st, write_sep(writer, SEP_END_DIRECT));
   }
 
   return reset_context(writer, RESET_GRAPH | RESET_INDENT);
@@ -1078,20 +1105,20 @@ serd_writer_set_prefix(SerdWriter*     writer,
                        const SerdNode* name,
                        const SerdNode* uri)
 {
-  const SerdStatus st = serd_env_set_prefix(writer->env, name, uri);
+  SerdStatus st = serd_env_set_prefix(writer->env, name, uri);
   if (st) {
     return st;
   }
 
   if (writer->syntax == SERD_TURTLE || writer->syntax == SERD_TRIG) {
-    terminate_context(writer);
-    sink("@prefix ", 8, writer);
-    sink(name->buf, name->n_bytes, writer);
-    sink(": <", 3, writer);
+    TRY(st, terminate_context(writer));
+    TRY(st, esink("@prefix ", 8, writer));
+    TRY(st, esink(name->buf, name->n_bytes, writer));
+    TRY(st, esink(": <", 3, writer));
     write_uri(writer, uri->buf, uri->n_bytes);
-    sink(">", 1, writer);
+    TRY(st, esink(">", 1, writer));
     writer->last_sep = SEP_NODE;
-    write_sep(writer, SEP_END_DIRECT);
+    TRY(st, write_sep(writer, SEP_END_DIRECT));
   }
 
   return reset_context(writer, RESET_GRAPH | RESET_INDENT);