Make function parameters const wherever possible

The early history of this code didn't tend to make parameters const, but the
"const density" is high enough now that I often find myself wondering if
something is mutable for some reason, or just old and sloppier.  So, eliminate
this confusion by making (hopefully) all function parameters const if possible.

9 files changed, 132 insertions, 116 deletions

diff --git a/src/byte_sink.h b/src/byte_sink.h
index 65b5eb12..b99b5551 100644
--- a/src/byte_sink.h
+++ b/src/byte_sink.h
@@ -22,7 +22,7 @@ typedef struct SerdByteSinkImpl {
 } SerdByteSink;
 
 static inline SerdByteSink
-serd_byte_sink_new(SerdSink sink, void* stream, size_t block_size)
+serd_byte_sink_new(SerdSink sink, void* const stream, const size_t block_size)
 {
   SerdByteSink bsink = {sink, stream, NULL, 0, block_size};
 
@@ -34,7 +34,7 @@ serd_byte_sink_new(SerdSink sink, void* stream, size_t block_size)
 }
 
 static inline SerdStatus
-serd_byte_sink_flush(SerdByteSink* bsink)
+serd_byte_sink_flush(SerdByteSink* const bsink)
 {
   if (bsink->block_size > 1 && bsink->size > 0) {
     const size_t size  = bsink->size;
@@ -48,7 +48,7 @@ serd_byte_sink_flush(SerdByteSink* bsink)
 }
 
 static inline void
-serd_byte_sink_free(SerdByteSink* bsink)
+serd_byte_sink_free(SerdByteSink* const bsink)
 {
   serd_byte_sink_flush(bsink);
   serd_free_aligned(bsink->buf);
@@ -56,7 +56,7 @@ serd_byte_sink_free(SerdByteSink* bsink)
 }
 
 static inline size_t
-serd_byte_sink_write(const void* buf, size_t len, SerdByteSink* bsink)
+serd_byte_sink_write(const void* buf, size_t len, SerdByteSink* const bsink)
 {
   if (len == 0) {
     return 0;
diff --git a/src/byte_source.h b/src/byte_source.h
index afd9ccb9..961fae72 100644
--- a/src/byte_source.h
+++ b/src/byte_source.h
@@ -58,14 +58,14 @@ SerdStatus
 serd_byte_source_page(SerdByteSource* source);
 
 static inline SERD_PURE_FUNC uint8_t
-serd_byte_source_peek(SerdByteSource* source)
+serd_byte_source_peek(SerdByteSource* const source)
 {
   assert(source->prepared);
   return source->read_buf[source->read_head];
 }
 
 static inline SerdStatus
-serd_byte_source_advance(SerdByteSource* source)
+serd_byte_source_advance(SerdByteSource* const source)
 {
   SerdStatus st = SERD_SUCCESS;
 
diff --git a/src/node.h b/src/node.h
index a4d5dcd5..c0886391 100644
--- a/src/node.h
+++ b/src/node.h
@@ -15,13 +15,13 @@ struct SerdNodeImpl {
 };
 
 static inline char* SERD_NONNULL
-serd_node_buffer(SerdNode* SERD_NONNULL node)
+serd_node_buffer(SerdNode* const SERD_NONNULL node)
 {
   return (char*)(node + 1);
 }
 
 static inline const char* SERD_NONNULL
-serd_node_buffer_c(const SerdNode* SERD_NONNULL node)
+serd_node_buffer_c(const SerdNode* const SERD_NONNULL node)
 {
   return (const char*)(node + 1);
 }
diff --git a/src/reader.h b/src/reader.h
index 7768f3b6..a867ffc0 100644
--- a/src/reader.h
+++ b/src/reader.h
@@ -110,7 +110,7 @@ SerdStatus
 read_turtleTrigDoc(SerdReader* reader);
 
 static inline int
-peek_byte(SerdReader* reader)
+peek_byte(SerdReader* const reader)
 {
   SerdByteSource* source = &reader->source;
 
@@ -118,7 +118,7 @@ peek_byte(SerdReader* reader)
 }
 
 static inline SerdStatus
-skip_byte(SerdReader* reader, const int byte)
+skip_byte(SerdReader* const reader, const int byte)
 {
   (void)byte;
 
@@ -128,7 +128,7 @@ skip_byte(SerdReader* reader, const int byte)
 }
 
 static inline int SERD_NODISCARD
-eat_byte_safe(SerdReader* reader, const int byte)
+eat_byte_safe(SerdReader* const reader, const int byte)
 {
   (void)byte;
 
@@ -139,7 +139,7 @@ eat_byte_safe(SerdReader* reader, const int byte)
 }
 
 static inline int SERD_NODISCARD
-eat_byte_check(SerdReader* reader, const int byte)
+eat_byte_check(SerdReader* const reader, const int byte)
 {
   const int c = peek_byte(reader);
   if (c != byte) {
@@ -150,7 +150,7 @@ eat_byte_check(SerdReader* reader, const int byte)
 }
 
 static inline SerdStatus
-eat_string(SerdReader* reader, const char* str, unsigned n)
+eat_string(SerdReader* const reader, const char* const str, const unsigned n)
 {
   for (unsigned i = 0; i < n; ++i) {
     if (!eat_byte_check(reader, ((const uint8_t*)str)[i])) {
@@ -161,7 +161,7 @@ eat_string(SerdReader* reader, const char* str, unsigned n)
 }
 
 static inline SerdStatus
-push_byte(SerdReader* reader, Ref ref, const int c)
+push_byte(SerdReader* const reader, const Ref ref, const int c)
 {
   assert(c >= 0);
   SERD_STACK_ASSERT_TOP(reader, ref);
@@ -180,7 +180,10 @@ push_byte(SerdReader* reader, Ref ref, const int c)
 }
 
 static inline void
-push_bytes(SerdReader* reader, Ref ref, const uint8_t* bytes, unsigned len)
+push_bytes(SerdReader* const    reader,
+           const Ref            ref,
+           const uint8_t* const bytes,
+           const unsigned       len)
 {
   for (unsigned i = 0; i < len; ++i) {
     push_byte(reader, ref, bytes[i]);
diff --git a/src/serd_internal.h b/src/serd_internal.h
index 388c12ec..5508c111 100644
--- a/src/serd_internal.h
+++ b/src/serd_internal.h
@@ -20,7 +20,9 @@
 /* Error reporting */
 
 static inline void
-serd_error(SerdErrorSink error_sink, void* handle, const SerdError* e)
+serd_error(const SerdErrorSink    error_sink,
+           void* const            handle,
+           const SerdError* const e)
 {
   if (error_sink) {
     error_sink(handle, e);
diff --git a/src/stack.h b/src/stack.h
index 388dd054..f82de9d2 100644
--- a/src/stack.h
+++ b/src/stack.h
@@ -24,7 +24,7 @@ typedef struct {
 #define SERD_STACK_BOTTOM sizeof(void*)
 
 static inline SerdStack
-serd_stack_new(size_t size)
+serd_stack_new(const size_t size)
 {
   SerdStack stack;
   stack.buf      = (uint8_t*)calloc(size, 1);
@@ -34,13 +34,13 @@ serd_stack_new(size_t size)
 }
 
 static inline bool
-serd_stack_is_empty(const SerdStack* stack)
+serd_stack_is_empty(const SerdStack* const stack)
 {
   return stack->size <= SERD_STACK_BOTTOM;
 }
 
 static inline void
-serd_stack_free(SerdStack* stack)
+serd_stack_free(SerdStack* const stack)
 {
   free(stack->buf);
   stack->buf      = NULL;
@@ -49,7 +49,7 @@ serd_stack_free(SerdStack* stack)
 }
 
 static inline void*
-serd_stack_push(SerdStack* stack, size_t n_bytes)
+serd_stack_push(SerdStack* const stack, const size_t n_bytes)
 {
   const size_t new_size = stack->size + n_bytes;
   if (stack->buf_size < new_size) {
@@ -64,14 +64,16 @@ serd_stack_push(SerdStack* stack, size_t n_bytes)
 }
 
 static inline void
-serd_stack_pop(SerdStack* stack, size_t n_bytes)
+serd_stack_pop(SerdStack* const stack, const size_t 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)
+serd_stack_push_aligned(SerdStack* const stack,
+                        const size_t     n_bytes,
+                        const size_t     align)
 {
   // Push one byte to ensure space for a pad count
   serd_stack_push(stack, 1);
@@ -89,7 +91,7 @@ serd_stack_push_aligned(SerdStack* stack, size_t n_bytes, size_t align)
 }
 
 static inline void
-serd_stack_pop_aligned(SerdStack* stack, size_t n_bytes)
+serd_stack_pop_aligned(SerdStack* const stack, const size_t n_bytes)
 {
   // Pop requested space down to aligned location
   serd_stack_pop(stack, n_bytes);
diff --git a/src/uri.c b/src/uri.c
index 9856ce45..189ee2b7 100644
--- a/src/uri.c
+++ b/src/uri.c
@@ -15,7 +15,7 @@
 #include <string.h>
 
 const uint8_t*
-serd_uri_to_path(const uint8_t* uri)
+serd_uri_to_path(const uint8_t* const uri)
 {
   assert(uri);
 
@@ -344,7 +344,7 @@ serd_uri_resolve(const SerdURI* const r,
 
 /** Write the path of `uri` starting at index `i` */
 static size_t
-write_path_tail(SerdSink             sink,
+write_path_tail(const SerdSink       sink,
                 void* const          stream,
                 const SerdURI* const uri,
                 const size_t         i)
@@ -372,7 +372,7 @@ write_path_tail(SerdSink             sink,
 
 /** Write the path of `uri` relative to the path of `base`. */
 static size_t
-write_rel_path(SerdSink             sink,
+write_rel_path(const SerdSink       sink,
                void* const          stream,
                const SerdURI* const uri,
                const SerdURI* const base)
@@ -413,7 +413,7 @@ write_rel_path(SerdSink             sink,
 }
 
 static uint8_t
-serd_uri_path_starts_without_slash(const SerdURI* uri)
+serd_uri_path_starts_without_slash(const SerdURI* const uri)
 {
   return ((uri->path_base.len || uri->path.len) &&
           ((!uri->path_base.len || uri->path_base.buf[0] != '/') &&
@@ -425,7 +425,7 @@ size_t
 serd_uri_serialise_relative(const SerdURI* const uri,
                             const SerdURI* const base,
                             const SerdURI* const root,
-                            SerdSink             sink,
+                            const SerdSink       sink,
                             void* const          stream)
 {
   assert(uri);
@@ -481,7 +481,9 @@ serd_uri_serialise_relative(const SerdURI* const uri,
 
 /// See http://tools.ietf.org/html/rfc3986#section-5.3
 size_t
-serd_uri_serialise(const SerdURI* const uri, SerdSink sink, void* const stream)
+serd_uri_serialise(const SerdURI* const uri,
+                   const SerdSink       sink,
+                   void* const          stream)
 {
   assert(uri);
   assert(sink);
diff --git a/src/uri_utils.h b/src/uri_utils.h
index 0d3bd74e..4005b47d 100644
--- a/src/uri_utils.h
+++ b/src/uri_utils.h
@@ -18,20 +18,20 @@ typedef struct {
 } SlashIndexes;
 
 static inline bool
-chunk_equals(const SerdChunk* a, const SerdChunk* b)
+chunk_equals(const SerdChunk* const a, const SerdChunk* const b)
 {
   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)
+uri_path_len(const SerdURI* const uri)
 {
   return uri->path_base.len + uri->path.len;
 }
 
 static inline uint8_t
-uri_path_at(const SerdURI* uri, size_t i)
+uri_path_at(const SerdURI* const uri, const size_t i)
 {
   return (i < uri->path_base.len) ? uri->path_base.buf[i]
                                   : uri->path.buf[i - uri->path_base.len];
@@ -46,7 +46,7 @@ uri_path_at(const SerdURI* uri, size_t i)
    otherwise it may merely share some leading path components).
 */
 static inline SERD_PURE_FUNC SlashIndexes
-uri_rooted_index(const SerdURI* uri, const SerdURI* root)
+uri_rooted_index(const SerdURI* const uri, const SerdURI* const root)
 {
   SlashIndexes indexes = {SIZE_MAX, SIZE_MAX};
 
@@ -84,14 +84,14 @@ uri_rooted_index(const SerdURI* uri, const SerdURI* root)
 
 /** Return true iff `uri` shares path components with `root` */
 static inline SERD_PURE_FUNC bool
-uri_is_related(const SerdURI* uri, const SerdURI* root)
+uri_is_related(const SerdURI* const uri, const SerdURI* const root)
 {
   return uri_rooted_index(uri, root).shared != SIZE_MAX;
 }
 
 /** 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)
+uri_is_under(const SerdURI* const uri, const SerdURI* const root)
 {
   const SlashIndexes indexes = uri_rooted_index(uri, root);
   return indexes.shared && indexes.shared != SIZE_MAX &&
diff --git a/src/writer.c b/src/writer.c
index c75d3fb7..0df44797 100644
--- a/src/writer.c
+++ b/src/writer.c
@@ -143,7 +143,7 @@ write_node(SerdWriter*        writer,
            SerdStatementFlags flags);
 
 SERD_NODISCARD static bool
-supports_abbrev(const SerdWriter* writer)
+supports_abbrev(const SerdWriter* const writer)
 {
   return writer->syntax == SERD_TURTLE || writer->syntax == SERD_TRIG;
 }
@@ -162,7 +162,7 @@ free_context(WriteContext* const ctx)
 
 SERD_LOG_FUNC(3, 4)
 static SerdStatus
-w_err(SerdWriter* writer, SerdStatus st, const char* fmt, ...)
+w_err(SerdWriter* const writer, const SerdStatus st, const char* const fmt, ...)
 {
   /* TODO: This results in errors with no file information, which is not
      helpful when re-serializing a file (particularly for "undefined
@@ -179,7 +179,7 @@ w_err(SerdWriter* writer, SerdStatus st, const char* fmt, ...)
 }
 
 static void
-copy_node(SerdNode* dst, const SerdNode* src)
+copy_node(SerdNode* const dst, const SerdNode* const src)
 {
   const size_t   new_size = src->n_bytes + 1U;
   uint8_t* const new_buf  = (uint8_t*)realloc((char*)dst->buf, new_size);
@@ -210,7 +210,7 @@ push_context(SerdWriter* const writer,
 }
 
 static void
-pop_context(SerdWriter* writer)
+pop_context(SerdWriter* const writer)
 {
   // Replace the current context with the top of the stack
   free_context(&writer->context);
@@ -223,7 +223,7 @@ pop_context(SerdWriter* writer)
 }
 
 SERD_NODISCARD static size_t
-sink(const void* buf, size_t len, SerdWriter* writer)
+sink(const void* const buf, const size_t len, SerdWriter* const writer)
 {
   const size_t written = serd_byte_sink_write(buf, len, &writer->byte_sink);
   if (written != len) {
@@ -239,7 +239,7 @@ sink(const void* buf, size_t len, SerdWriter* writer)
 }
 
 SERD_NODISCARD static inline SerdStatus
-esink(const void* buf, size_t len, SerdWriter* writer)
+esink(const void* const buf, const size_t len, SerdWriter* const writer)
 {
   return sink(buf, len, writer) == len ? SERD_SUCCESS : SERD_ERR_BAD_WRITE;
 }
@@ -247,10 +247,10 @@ esink(const void* buf, size_t len, SerdWriter* writer)
 // 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
-write_character(SerdWriter*    writer,
-                const uint8_t* utf8,
-                uint8_t*       size,
-                SerdStatus*    st)
+write_character(SerdWriter* const    writer,
+                const uint8_t* const utf8,
+                uint8_t* const       size,
+                SerdStatus* const    st)
 {
   char           escape[11] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   const uint32_t c          = parse_utf8_char(utf8, size);
@@ -288,10 +288,10 @@ uri_must_escape(const uint8_t c)
 }
 
 static size_t
-write_uri(SerdWriter*    writer,
-          const uint8_t* utf8,
-          size_t         n_bytes,
-          SerdStatus*    st)
+write_uri(SerdWriter* const    writer,
+          const uint8_t* const utf8,
+          const size_t         n_bytes,
+          SerdStatus* const    st)
 {
   size_t len = 0;
   for (size_t i = 0; i < n_bytes;) {
@@ -336,7 +336,9 @@ write_uri(SerdWriter*    writer,
 }
 
 SERD_NODISCARD static SerdStatus
-ewrite_uri(SerdWriter* writer, const uint8_t* utf8, size_t n_bytes)
+ewrite_uri(SerdWriter* const    writer,
+           const uint8_t* const utf8,
+           const size_t         n_bytes)
 {
   SerdStatus st = SERD_SUCCESS;
   write_uri(writer, utf8, n_bytes, &st);
@@ -347,7 +349,7 @@ ewrite_uri(SerdWriter* writer, const uint8_t* utf8, size_t n_bytes)
 }
 
 SERD_NODISCARD static SerdStatus
-write_uri_from_node(SerdWriter* writer, const SerdNode* node)
+write_uri_from_node(SerdWriter* const writer, const SerdNode* const node)
 {
   return ewrite_uri(writer, node->buf, node->n_bytes);
 }
@@ -369,7 +371,9 @@ lname_must_escape(const uint8_t c)
 }
 
 SERD_NODISCARD static SerdStatus
-write_lname(SerdWriter* writer, const uint8_t* utf8, size_t n_bytes)
+write_lname(SerdWriter* const    writer,
+            const uint8_t* const utf8,
+            const size_t         n_bytes)
 {
   SerdStatus st = SERD_SUCCESS;
   for (size_t i = 0; i < n_bytes; ++i) {
@@ -395,10 +399,10 @@ write_lname(SerdWriter* writer, const uint8_t* utf8, size_t n_bytes)
 }
 
 SERD_NODISCARD static SerdStatus
-write_text(SerdWriter*    writer,
-           TextContext    ctx,
-           const uint8_t* utf8,
-           size_t         n_bytes)
+write_text(SerdWriter* const    writer,
+           const TextContext    ctx,
+           const uint8_t* const utf8,
+           const size_t         n_bytes)
 {
   size_t     n_consecutive_quotes = 0;
   SerdStatus st                   = SERD_SUCCESS;
@@ -509,7 +513,7 @@ typedef struct {
 } UriSinkContext;
 
 SERD_NODISCARD static size_t
-uri_sink(const void* buf, size_t len, void* stream)
+uri_sink(const void* const buf, const size_t len, void* const stream)
 {
   UriSinkContext* const context = (UriSinkContext*)stream;
   SerdWriter* const     writer  = context->writer;
@@ -518,7 +522,7 @@ uri_sink(const void* buf, size_t len, void* stream)
 }
 
 SERD_NODISCARD static SerdStatus
-write_newline(SerdWriter* writer)
+write_newline(SerdWriter* const writer)
 {
   SerdStatus st = SERD_SUCCESS;
 
@@ -531,7 +535,7 @@ write_newline(SerdWriter* writer)
 }
 
 SERD_NODISCARD static SerdStatus
-write_sep(SerdWriter* writer, const Sep sep)
+write_sep(SerdWriter* const writer, const Sep sep)
 {
   SerdStatus           st   = SERD_SUCCESS;
   const SepRule* const rule = &rules[sep];
@@ -585,7 +589,7 @@ write_sep(SerdWriter* writer, const Sep sep)
 }
 
 static void
-free_anon_stack(SerdWriter* writer)
+free_anon_stack(SerdWriter* const writer)
 {
   while (!serd_stack_is_empty(&writer->anon_stack)) {
     pop_context(writer);
@@ -593,7 +597,7 @@ free_anon_stack(SerdWriter* writer)
 }
 
 static SerdStatus
-reset_context(SerdWriter* writer, const unsigned flags)
+reset_context(SerdWriter* const writer, const unsigned flags)
 {
   free_anon_stack(writer);
 
@@ -639,11 +643,11 @@ get_xsd_name(const SerdEnv* const env, const SerdNode* const datatype)
 }
 
 SERD_NODISCARD static SerdStatus
-write_literal(SerdWriter*        writer,
-              const SerdNode*    node,
-              const SerdNode*    datatype,
-              const SerdNode*    lang,
-              SerdStatementFlags flags)
+write_literal(SerdWriter* const        writer,
+              const SerdNode* const    node,
+              const SerdNode* const    datatype,
+              const SerdNode* const    lang,
+              const SerdStatementFlags flags)
 {
   SerdStatus st = SERD_SUCCESS;
 
@@ -679,7 +683,7 @@ write_literal(SerdWriter*        writer,
 
 // Return true iff `buf` is a valid prefixed name prefix or suffix
 static bool
-is_name(const uint8_t* buf, const size_t len)
+is_name(const uint8_t* const buf, const size_t len)
 {
   // TODO: This is more strict than it should be
   for (size_t i = 0; i < len; ++i) {
@@ -692,9 +696,9 @@ is_name(const uint8_t* buf, const size_t len)
 }
 
 SERD_NODISCARD static SerdStatus
-write_uri_node(SerdWriter* const writer,
-               const SerdNode*   node,
-               const Field       field)
+write_uri_node(SerdWriter* const     writer,
+               const SerdNode* const node,
+               const Field           field)
 {
   SerdStatus st     = SERD_SUCCESS;
   SerdNode   prefix = SERD_NODE_NULL;
@@ -789,7 +793,7 @@ write_curie(SerdWriter* const writer, const SerdNode* const node)
 
 SERD_NODISCARD static SerdStatus
 write_blank(SerdWriter* const        writer,
-            const SerdNode*          node,
+            const SerdNode* const    node,
             const Field              field,
             const SerdStatementFlags flags)
 {
@@ -828,12 +832,12 @@ write_blank(SerdWriter* const        writer,
 }
 
 SERD_NODISCARD static SerdStatus
-write_node(SerdWriter*        writer,
-           const SerdNode*    node,
-           const SerdNode*    datatype,
-           const SerdNode*    lang,
-           Field              field,
-           SerdStatementFlags flags)
+write_node(SerdWriter* const        writer,
+           const SerdNode* const    node,
+           const SerdNode* const    datatype,
+           const SerdNode* const    lang,
+           const Field              field,
+           const SerdStatementFlags flags)
 {
   return (node->type == SERD_LITERAL)
            ? write_literal(writer, node, datatype, lang, flags)
@@ -844,13 +848,15 @@ write_node(SerdWriter*        writer,
 }
 
 static bool
-is_resource(const SerdNode* node)
+is_resource(const SerdNode* const node)
 {
   return node->buf && node->type > SERD_LITERAL;
 }
 
 SERD_NODISCARD static SerdStatus
-write_pred(SerdWriter* writer, SerdStatementFlags flags, const SerdNode* pred)
+write_pred(SerdWriter* const        writer,
+           const SerdStatementFlags flags,
+           const SerdNode* const    pred)
 {
   SerdStatus st = SERD_SUCCESS;
 
@@ -864,12 +870,12 @@ write_pred(SerdWriter* writer, SerdStatementFlags flags, const SerdNode* pred)
 }
 
 SERD_NODISCARD static SerdStatus
-write_list_next(SerdWriter*        writer,
-                SerdStatementFlags flags,
-                const SerdNode*    predicate,
-                const SerdNode*    object,
-                const SerdNode*    datatype,
-                const SerdNode*    lang)
+write_list_next(SerdWriter* const        writer,
+                const SerdStatementFlags flags,
+                const SerdNode* const    predicate,
+                const SerdNode* const    object,
+                const SerdNode* const    datatype,
+                const SerdNode* const    lang)
 {
   SerdStatus st = SERD_SUCCESS;
 
@@ -888,7 +894,7 @@ write_list_next(SerdWriter*        writer,
 }
 
 SERD_NODISCARD static SerdStatus
-terminate_context(SerdWriter* writer)
+terminate_context(SerdWriter* const writer)
 {
   SerdStatus st = SERD_SUCCESS;
 
@@ -904,14 +910,14 @@ terminate_context(SerdWriter* writer)
 }
 
 SerdStatus
-serd_writer_write_statement(SerdWriter*        writer,
-                            SerdStatementFlags flags,
-                            const SerdNode*    graph,
-                            const SerdNode*    subject,
-                            const SerdNode*    predicate,
-                            const SerdNode*    object,
-                            const SerdNode*    datatype,
-                            const SerdNode*    lang)
+serd_writer_write_statement(SerdWriter* const     writer,
+                            SerdStatementFlags    flags,
+                            const SerdNode* const graph,
+                            const SerdNode* const subject,
+                            const SerdNode* const predicate,
+                            const SerdNode* const object,
+                            const SerdNode* const datatype,
+                            const SerdNode* const lang)
 {
   assert(writer);
   assert(subject);
@@ -1064,7 +1070,7 @@ serd_writer_write_statement(SerdWriter*        writer,
 }
 
 SerdStatus
-serd_writer_end_anon(SerdWriter* writer, const SerdNode* node)
+serd_writer_end_anon(SerdWriter* const writer, const SerdNode* const node)
 {
   assert(writer);
 
@@ -1095,7 +1101,7 @@ serd_writer_end_anon(SerdWriter* writer, const SerdNode* node)
 }
 
 SerdStatus
-serd_writer_finish(SerdWriter* writer)
+serd_writer_finish(SerdWriter* const writer)
 {
   assert(writer);
 
@@ -1107,12 +1113,12 @@ serd_writer_finish(SerdWriter* writer)
 }
 
 SerdWriter*
-serd_writer_new(SerdSyntax     syntax,
-                SerdStyle      style,
-                SerdEnv*       env,
-                const SerdURI* base_uri,
-                SerdSink       ssink,
-                void*          stream)
+serd_writer_new(const SerdSyntax     syntax,
+                const SerdStyle      style,
+                SerdEnv* const       env,
+                const SerdURI* const base_uri,
+                SerdSink             ssink,
+                void* const          stream)
 {
   assert(env);
   assert(ssink);
@@ -1135,9 +1141,9 @@ serd_writer_new(SerdSyntax     syntax,
 }
 
 void
-serd_writer_set_error_sink(SerdWriter*   writer,
-                           SerdErrorSink error_sink,
-                           void*         error_handle)
+serd_writer_set_error_sink(SerdWriter* const   writer,
+                           const SerdErrorSink error_sink,
+                           void* const         error_handle)
 {
   assert(writer);
   assert(error_sink);
@@ -1146,7 +1152,8 @@ serd_writer_set_error_sink(SerdWriter*   writer,
 }
 
 void
-serd_writer_chop_blank_prefix(SerdWriter* writer, const uint8_t* prefix)
+serd_writer_chop_blank_prefix(SerdWriter* const    writer,
+                              const uint8_t* const prefix)
 {
   assert(writer);
 
@@ -1163,7 +1170,7 @@ serd_writer_chop_blank_prefix(SerdWriter* writer, const uint8_t* prefix)
 }
 
 SerdStatus
-serd_writer_set_base_uri(SerdWriter* writer, const SerdNode* uri)
+serd_writer_set_base_uri(SerdWriter* const writer, const SerdNode* const uri)
 {
   assert(writer);
 
@@ -1185,7 +1192,7 @@ serd_writer_set_base_uri(SerdWriter* writer, const SerdNode* uri)
 }
 
 SerdStatus
-serd_writer_set_root_uri(SerdWriter* writer, const SerdNode* uri)
+serd_writer_set_root_uri(SerdWriter* const writer, const SerdNode* const uri)
 {
   assert(writer);
 
@@ -1205,9 +1212,9 @@ serd_writer_set_root_uri(SerdWriter* writer, const SerdNode* uri)
 }
 
 SerdStatus
-serd_writer_set_prefix(SerdWriter*     writer,
-                       const SerdNode* name,
-                       const SerdNode* uri)
+serd_writer_set_prefix(SerdWriter* const     writer,
+                       const SerdNode* const name,
+                       const SerdNode* const uri)
 {
   assert(writer);
   assert(name);
@@ -1231,7 +1238,7 @@ serd_writer_set_prefix(SerdWriter*     writer,
 }
 
 void
-serd_writer_free(SerdWriter* writer)
+serd_writer_free(SerdWriter* const writer)
 {
   if (!writer) {
     return;
@@ -1250,14 +1257,14 @@ serd_writer_free(SerdWriter* writer)
 }
 
 SerdEnv*
-serd_writer_get_env(SerdWriter* writer)
+serd_writer_get_env(SerdWriter* const writer)
 {
   assert(writer);
   return writer->env;
 }
 
 size_t
-serd_file_sink(const void* buf, size_t len, void* stream)
+serd_file_sink(const void* const buf, const size_t len, void* const stream)
 {
   assert(buf);
   assert(stream);
@@ -1265,7 +1272,7 @@ serd_file_sink(const void* buf, size_t len, void* stream)
 }
 
 size_t
-serd_chunk_sink(const void* buf, size_t len, void* stream)
+serd_chunk_sink(const void* const buf, const size_t len, void* const stream)
 {
   assert(buf);
   assert(stream);
@@ -1281,7 +1288,7 @@ serd_chunk_sink(const void* buf, size_t len, void* stream)
 }
 
 uint8_t*
-serd_chunk_sink_finish(SerdChunk* stream)
+serd_chunk_sink_finish(SerdChunk* const stream)
 {
   assert(stream);
   serd_chunk_sink("", 1, stream);