Use char* for strings in public API

The constant casting just makes user code a mess, for no benefit.

23 files changed, 344 insertions, 385 deletions

diff --git a/NEWS b/NEWS
index 9a7b206a..c3e1508d 100644
--- a/NEWS
+++ b/NEWS
@@ -3,6 +3,7 @@ serd (1.0.1) unstable;
   * Add SerdBuffer for mutable buffers to keep SerdChunk const-correct
   * Remove serd_uri_to_path()
   * Remove useless character counting from API
+  * Use char* for strings in public API
 
  -- David Robillard <d@drobilla.net>  Wed, 13 Jan 2021 13:29:44 +0000
 
diff --git a/include/serd/serd.h b/include/serd/serd.h
index 0d760f09..7b3d0cf7 100644
--- a/include/serd/serd.h
+++ b/include/serd/serd.h
@@ -185,16 +185,16 @@ 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)
-  SerdNodeFlags                flags;   ///< Node flags (string properties)
-  SerdType                     type;    ///< Node type
+  const char* SERD_NULLABLE buf;     ///< Value string
+  size_t                    n_bytes; ///< Size in bytes (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 char* SERD_NULLABLE buf; ///< Start of chunk
+  size_t                    len; ///< Length of chunk in bytes
 } SerdChunk;
 
 /// A mutable buffer in memory
@@ -205,12 +205,12 @@ typedef struct {
 
 /// 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 char* 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;
 
 /**
@@ -262,7 +262,7 @@ serd_free(void* SERD_NULLABLE ptr);
 
 /// Return a string describing a status code
 SERD_CONST_API
-const uint8_t* SERD_NONNULL
+const char* SERD_NONNULL
 serd_strerror(SerdStatus status);
 
 /**
@@ -274,8 +274,7 @@ serd_strerror(SerdStatus status);
 */
 SERD_API
 size_t
-serd_strlen(const uint8_t* SERD_NONNULL  str,
-            SerdNodeFlags* SERD_NULLABLE flags);
+serd_strlen(const char* SERD_NONNULL str, SerdNodeFlags* SERD_NULLABLE flags);
 
 /**
    Parse a string to a double.
@@ -302,9 +301,9 @@ serd_strtod(const char* SERD_NONNULL str,
 */
 SERD_API
 void* SERD_ALLOCATED
-serd_base64_decode(const uint8_t* SERD_NONNULL str,
-                   size_t                      len,
-                   size_t* SERD_NONNULL        size);
+serd_base64_decode(const char* SERD_NONNULL str,
+                   size_t                   len,
+                   size_t* SERD_NONNULL     size);
 
 /**
    @}
@@ -362,19 +361,19 @@ static const SerdURI SERD_URI_NULL =
    @return The path component of the URI.
 */
 SERD_API
-uint8_t* SERD_NULLABLE
-serd_file_uri_parse(const uint8_t* SERD_NONNULL uri,
-                    uint8_t* SERD_NONNULL* SERD_NULLABLE hostname);
+char* SERD_NULLABLE
+serd_file_uri_parse(const char* SERD_NONNULL uri,
+                    char* SERD_NONNULL* SERD_NULLABLE hostname);
 
 /// Return true iff `utf8` starts with a valid URI scheme
 SERD_PURE_API
 bool
-serd_uri_string_has_scheme(const uint8_t* SERD_NULLABLE utf8);
+serd_uri_string_has_scheme(const char* SERD_NULLABLE utf8);
 
 /// Parse `utf8`, writing result to `out`
 SERD_API
 SerdStatus
-serd_uri_parse(const uint8_t* SERD_NONNULL utf8, SerdURI* SERD_NONNULL out);
+serd_uri_parse(const char* SERD_NONNULL utf8, SerdURI* SERD_NONNULL out);
 
 /**
    Set target `t` to reference `r` resolved against `base`.
@@ -424,7 +423,7 @@ static const SerdNode SERD_NODE_NULL = {NULL, 0, 0, SERD_NOTHING};
 */
 SERD_API
 SerdNode
-serd_node_from_string(SerdType type, const uint8_t* SERD_NULLABLE str);
+serd_node_from_string(SerdType type, const char* SERD_NULLABLE str);
 
 /**
    Make a (shallow) node from a prefix of `str`.
@@ -434,9 +433,9 @@ serd_node_from_string(SerdType type, const uint8_t* SERD_NULLABLE str);
 */
 SERD_API
 SerdNode
-serd_node_from_substring(SerdType                     type,
-                         const uint8_t* SERD_NULLABLE str,
-                         size_t                       len);
+serd_node_from_substring(SerdType                  type,
+                         const char* SERD_NULLABLE str,
+                         size_t                    len);
 
 /// Simple wrapper for serd_node_new_uri() to resolve a URI node
 SERD_API
@@ -448,7 +447,7 @@ serd_node_new_uri_from_node(const SerdNode* SERD_NONNULL uri_node,
 /// Simple wrapper for serd_node_new_uri() to resolve a URI string
 SERD_API
 SerdNode
-serd_node_new_uri_from_string(const uint8_t* SERD_NULLABLE str,
+serd_node_new_uri_from_string(const char* SERD_NULLABLE    str,
                               const SerdURI* SERD_NULLABLE base,
                               SerdURI* SERD_NULLABLE       out);
 
@@ -463,9 +462,9 @@ serd_node_new_uri_from_string(const uint8_t* SERD_NULLABLE str,
 */
 SERD_API
 SerdNode
-serd_node_new_file_uri(const uint8_t* SERD_NONNULL  path,
-                       const uint8_t* SERD_NULLABLE hostname,
-                       SerdURI* SERD_NULLABLE       out);
+serd_node_new_file_uri(const char* SERD_NONNULL  path,
+                       const char* SERD_NULLABLE hostname,
+                       SerdURI* SERD_NULLABLE    out);
 
 /**
    Create a new node by serialising `uri` into a new string.
@@ -666,9 +665,9 @@ serd_env_set_prefix(SerdEnv* SERD_NONNULL        env,
 /// Set a namespace prefix
 SERD_API
 SerdStatus
-serd_env_set_prefix_from_strings(SerdEnv* SERD_NONNULL       env,
-                                 const uint8_t* SERD_NONNULL name,
-                                 const uint8_t* SERD_NONNULL uri);
+serd_env_set_prefix_from_strings(SerdEnv* SERD_NONNULL    env,
+                                 const char* SERD_NONNULL name,
+                                 const char* SERD_NONNULL uri);
 
 /// Qualify `uri` into a CURIE if possible
 SERD_API
@@ -764,8 +763,8 @@ serd_reader_get_handle(const SerdReader* SERD_NONNULL reader);
 */
 SERD_API
 void
-serd_reader_add_blank_prefix(SerdReader* SERD_NONNULL     reader,
-                             const uint8_t* SERD_NULLABLE prefix);
+serd_reader_add_blank_prefix(SerdReader* SERD_NONNULL  reader,
+                             const char* SERD_NULLABLE prefix);
 
 /**
    Set the URI of the default graph.
@@ -782,8 +781,8 @@ serd_reader_set_default_graph(SerdReader* SERD_NONNULL      reader,
 /// Read a file at a given `uri`
 SERD_API
 SerdStatus
-serd_reader_read_file(SerdReader* SERD_NONNULL    reader,
-                      const uint8_t* SERD_NONNULL uri);
+serd_reader_read_file(SerdReader* SERD_NONNULL reader,
+                      const char* SERD_NONNULL uri);
 
 /**
    Start an incremental read from a file handle.
@@ -795,10 +794,10 @@ serd_reader_read_file(SerdReader* SERD_NONNULL    reader,
 */
 SERD_API
 SerdStatus
-serd_reader_start_stream(SerdReader* SERD_NONNULL     reader,
-                         FILE* SERD_NONNULL           file,
-                         const uint8_t* SERD_NULLABLE name,
-                         bool                         bulk);
+serd_reader_start_stream(SerdReader* SERD_NONNULL  reader,
+                         FILE* SERD_NONNULL        file,
+                         const char* SERD_NULLABLE name,
+                         bool                      bulk);
 
 /**
    Start an incremental read from a user-specified source.
@@ -812,7 +811,7 @@ serd_reader_start_source_stream(SerdReader* SERD_NONNULL         reader,
                                 SerdSource SERD_NONNULL          read_func,
                                 SerdStreamErrorFunc SERD_NONNULL error_func,
                                 void* SERD_NONNULL               stream,
-                                const uint8_t* SERD_NULLABLE     name,
+                                const char* SERD_NULLABLE        name,
                                 size_t                           page_size);
 
 /**
@@ -835,9 +834,9 @@ serd_reader_end_stream(SerdReader* SERD_NONNULL reader);
 /// Read `file`
 SERD_API
 SerdStatus
-serd_reader_read_file_handle(SerdReader* SERD_NONNULL     reader,
-                             FILE* SERD_NONNULL           file,
-                             const uint8_t* SERD_NULLABLE name);
+serd_reader_read_file_handle(SerdReader* SERD_NONNULL  reader,
+                             FILE* SERD_NONNULL        file,
+                             const char* SERD_NULLABLE name);
 
 /// Read a user-specified byte source
 SERD_API
@@ -846,14 +845,14 @@ serd_reader_read_source(SerdReader* SERD_NONNULL         reader,
                         SerdSource SERD_NONNULL          source,
                         SerdStreamErrorFunc SERD_NONNULL error,
                         void* SERD_NONNULL               stream,
-                        const uint8_t* SERD_NULLABLE     name,
+                        const char* SERD_NULLABLE        name,
                         size_t                           page_size);
 
 /// Read `utf8`
 SERD_API
 SerdStatus
-serd_reader_read_string(SerdReader* SERD_NONNULL    reader,
-                        const uint8_t* SERD_NONNULL utf8);
+serd_reader_read_string(SerdReader* SERD_NONNULL reader,
+                        const char* SERD_NONNULL utf8);
 
 /// Free `reader`
 SERD_API
@@ -919,7 +918,7 @@ serd_buffer_sink(const void* SERD_NONNULL buf,
    terminated (by this function) and owned by the caller.
 */
 SERD_API
-uint8_t* SERD_NULLABLE
+char* SERD_NULLABLE
 serd_buffer_sink_finish(SerdBuffer* SERD_NONNULL stream);
 
 /**
@@ -942,8 +941,8 @@ serd_writer_set_error_sink(SerdWriter* SERD_NONNULL   writer,
 */
 SERD_API
 void
-serd_writer_chop_blank_prefix(SerdWriter* SERD_NONNULL     writer,
-                              const uint8_t* SERD_NULLABLE prefix);
+serd_writer_chop_blank_prefix(SerdWriter* SERD_NONNULL  writer,
+                              const char* SERD_NULLABLE prefix);
 
 /**
    Set the current output base URI, and emit a directive if applicable.
diff --git a/src/base64.c b/src/base64.c
index bca3dfd3..0edf8a0f 100644
--- a/src/base64.c
+++ b/src/base64.c
@@ -73,7 +73,6 @@ serd_base64_encode(uint8_t* const    str,
                    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);
@@ -107,26 +106,23 @@ decode_chunk(const uint8_t in[4], uint8_t out[3])
 }
 
 void*
-serd_base64_decode(const uint8_t* str, size_t len, size_t* size)
+serd_base64_decode(const char* str, size_t len, size_t* size)
 {
-  void* buf = malloc((len * 3) / 4 + 2);
+  const uint8_t* const ustr = (const uint8_t*)str;
 
-  *size = 0;
+  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++];
+      for (; i < len && !is_base64(ustr[i]); ++i) {
+      } // Skip junk
+      in[n_in] = ustr[i++];
     }
-
     if (n_in > 1) {
       *size += decode_chunk(in, (uint8_t*)buf + j);
     }
   }
-
   return buf;
 }
diff --git a/src/byte_sink.h b/src/byte_sink.h
index dc55ba1e..d5222843 100644
--- a/src/byte_sink.h
+++ b/src/byte_sink.h
@@ -23,13 +23,12 @@
 #include "serd/serd.h"
 
 #include <stddef.h>
-#include <stdint.h>
 #include <string.h>
 
 typedef struct SerdByteSinkImpl {
   SerdSink sink;
   void*    stream;
-  uint8_t* buf;
+  char*    buf;
   size_t   size;
   size_t   block_size;
 } SerdByteSink;
@@ -37,12 +36,13 @@ typedef struct SerdByteSinkImpl {
 static inline SerdByteSink
 serd_byte_sink_new(SerdSink sink, void* stream, size_t block_size)
 {
-  SerdByteSink bsink = {sink, stream, NULL, 0, block_size};
-
-  if (block_size > 1) {
-    bsink.buf = (uint8_t*)serd_allocate_buffer(block_size);
-  }
-
+  SerdByteSink bsink;
+  bsink.sink       = sink;
+  bsink.stream     = stream;
+  bsink.size       = 0;
+  bsink.block_size = block_size;
+  bsink.buf =
+    ((block_size > 1) ? (char*)serd_allocate_buffer(block_size) : NULL);
   return bsink;
 }
 
@@ -82,7 +82,7 @@ serd_byte_sink_write(const void* buf, size_t len, SerdByteSink* bsink)
     // 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;
+    buf = (const char*)buf + n;
     len -= n;
 
     // Flush page if buffer is full
@@ -91,7 +91,6 @@ serd_byte_sink_write(const void* buf, size_t len, SerdByteSink* bsink)
       bsink->size = 0;
     }
   }
-
   return orig_len;
 }
 
diff --git a/src/byte_source.c b/src/byte_source.c
index 9f7e4e59..594dd785 100644
--- a/src/byte_source.c
+++ b/src/byte_source.c
@@ -51,7 +51,7 @@ serd_byte_source_open_source(SerdByteSource*     source,
                              SerdSource          read_func,
                              SerdStreamErrorFunc error_func,
                              void*               stream,
-                             const uint8_t*      name,
+                             const char*         name,
                              size_t              page_size)
 {
   const Cursor cur = {name, 1, 1};
@@ -90,13 +90,13 @@ serd_byte_source_prepare(SerdByteSource* source)
 }
 
 SerdStatus
-serd_byte_source_open_string(SerdByteSource* source, const uint8_t* utf8)
+serd_byte_source_open_string(SerdByteSource* source, const char* utf8)
 {
-  const Cursor cur = {(const uint8_t*)"(string)", 1, 1};
+  const Cursor cur = {"(string)", 1, 1};
 
   memset(source, '\0', sizeof(*source));
   source->cur      = cur;
-  source->read_buf = utf8;
+  source->read_buf = (const uint8_t*)utf8;
   return SERD_SUCCESS;
 }
 
diff --git a/src/byte_source.h b/src/byte_source.h
index 48794a37..7a42feaa 100644
--- a/src/byte_source.h
+++ b/src/byte_source.h
@@ -26,9 +26,9 @@
 #include <stdio.h>
 
 typedef struct {
-  const uint8_t* filename;
-  unsigned       line;
-  unsigned       col;
+  const char* filename;
+  unsigned    line;
+  unsigned    col;
 } Cursor;
 
 typedef struct {
@@ -51,14 +51,14 @@ SerdStatus
 serd_byte_source_open_file(SerdByteSource* source, FILE* file, bool bulk);
 
 SerdStatus
-serd_byte_source_open_string(SerdByteSource* source, const uint8_t* utf8);
+serd_byte_source_open_string(SerdByteSource* source, const char* utf8);
 
 SerdStatus
 serd_byte_source_open_source(SerdByteSource*     source,
                              SerdSource          read_func,
                              SerdStreamErrorFunc error_func,
                              void*               stream,
-                             const uint8_t*      name,
+                             const char*         name,
                              size_t              page_size);
 
 SerdStatus
diff --git a/src/env.c b/src/env.c
index 05274df6..9d4721d2 100644
--- a/src/env.c
+++ b/src/env.c
@@ -17,7 +17,6 @@
 #include "serd/serd.h"
 
 #include <stdbool.h>
-#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -100,7 +99,7 @@ serd_env_set_base_uri(SerdEnv* env, const SerdNode* uri)
 }
 
 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 char* name, size_t name_len)
 {
   for (size_t i = 0; i < env->n_prefixes; ++i) {
     const SerdNode* const prefix_name = &env->prefixes[i].name;
@@ -157,9 +156,9 @@ serd_env_set_prefix(SerdEnv* env, const SerdNode* name, const SerdNode* uri)
 }
 
 SerdStatus
-serd_env_set_prefix_from_strings(SerdEnv*       env,
-                                 const uint8_t* name,
-                                 const uint8_t* uri)
+serd_env_set_prefix_from_strings(SerdEnv*    env,
+                                 const char* name,
+                                 const char* uri)
 {
   const SerdNode name_node = serd_node_from_string(SERD_LITERAL, name);
   const SerdNode uri_node  = serd_node_from_string(SERD_URI, uri);
@@ -176,9 +175,7 @@ serd_env_qualify(const SerdEnv*  env,
   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)) {
+      if (!strncmp(uri->buf, 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;
@@ -195,8 +192,8 @@ 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);
+  const char* const colon =
+    (const char*)memchr(curie->buf, ':', curie->n_bytes + 1);
   if (curie->type != SERD_CURIE || !colon) {
     return SERD_ERR_BAD_ARG;
   }
@@ -231,9 +228,9 @@ serd_env_expand_node(const SerdEnv* env, const SerdNode* node)
       return SERD_NODE_NULL;
     }
     const size_t len = prefix.len + suffix.len;
-    uint8_t*     buf = (uint8_t*)malloc(len + 1);
+    char*        buf = (char*)malloc(len + 1);
     SerdNode     ret = {buf, len, 0, SERD_URI};
-    snprintf((char*)buf, ret.n_bytes + 1, "%s%s", prefix.buf, suffix.buf);
+    snprintf(buf, ret.n_bytes + 1, "%s%s", prefix.buf, suffix.buf);
     return ret;
   }
   case SERD_BLANK:
diff --git a/src/n3.c b/src/n3.c
index 9aae8a19..e64cfc50 100644
--- a/src/n3.c
+++ b/src/n3.c
@@ -980,11 +980,10 @@ 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);
+  const Ref ref = *dest = push_node(reader,
+                                    SERD_BLANK,
+                                    reader->bprefix ? reader->bprefix : "",
+                                    reader->bprefix_len);
 
   int c = peek_byte(reader); // First: (PN_CHARS | '_' | [0-9])
   if (is_digit(c) || c == '_') {
@@ -1023,7 +1022,6 @@ read_BLANK_NODE_LABEL(SerdReader* reader, Ref* dest, bool* ate_dot)
       }
     }
   }
-
   return SERD_SUCCESS;
 }
 
@@ -1556,7 +1554,7 @@ tokcmp(SerdReader* reader, Ref ref, const char* tok, size_t n)
     return -1;
   }
 
-  return serd_strncasecmp((const char*)node->buf, tok, n);
+  return serd_strncasecmp(node->buf, tok, n);
 }
 
 SerdStatus
diff --git a/src/node.c b/src/node.c
index cbb6762b..585f1443 100644
--- a/src/node.c
+++ b/src/node.c
@@ -39,7 +39,7 @@
 #endif
 
 SerdNode
-serd_node_from_string(SerdType type, const uint8_t* str)
+serd_node_from_string(SerdType type, const char* str)
 {
   if (!str) {
     return SERD_NODE_NULL;
@@ -52,7 +52,7 @@ serd_node_from_string(SerdType type, const uint8_t* str)
 }
 
 SerdNode
-serd_node_from_substring(SerdType type, const uint8_t* str, const size_t len)
+serd_node_from_substring(SerdType type, const char* str, const size_t len)
 {
   if (!str) {
     return SERD_NODE_NULL;
@@ -72,7 +72,7 @@ serd_node_copy(const SerdNode* node)
   }
 
   SerdNode copy = *node;
-  uint8_t* buf  = (uint8_t*)malloc(copy.n_bytes + 1);
+  char*    buf  = (char*)malloc(copy.n_bytes + 1);
   memcpy(buf, node->buf, copy.n_bytes + 1);
   copy.buf = buf;
   return copy;
@@ -83,8 +83,7 @@ serd_node_equals(const SerdNode* a, const SerdNode* b)
 {
   return (a == b) ||
          (a->type == b->type && a->n_bytes == b->n_bytes &&
-          ((a->buf == b->buf) ||
-           !memcmp((const char*)a->buf, (const char*)b->buf, a->n_bytes + 1)));
+          ((a->buf == b->buf) || !memcmp(a->buf, b->buf, a->n_bytes + 1)));
 }
 
 static size_t
@@ -109,7 +108,7 @@ serd_uri_string_length(const SerdURI* uri)
 static size_t
 string_sink(const void* buf, size_t len, void* stream)
 {
-  uint8_t** ptr = (uint8_t**)stream;
+  char** ptr = (char**)stream;
   memcpy(*ptr, buf, len);
   *ptr += len;
   return len;
@@ -126,7 +125,7 @@ serd_node_new_uri_from_node(const SerdNode* uri_node,
 }
 
 SerdNode
-serd_node_new_uri_from_string(const uint8_t* str,
+serd_node_new_uri_from_string(const char*    str,
                               const SerdURI* base,
                               SerdURI*       out)
 {
@@ -141,7 +140,7 @@ serd_node_new_uri_from_string(const uint8_t* str,
 }
 
 static inline bool
-is_uri_path_char(const uint8_t c)
+is_uri_path_char(const char c)
 {
   if (is_alpha(c) || is_digit(c)) {
     return true;
@@ -177,28 +176,26 @@ is_uri_path_char(const uint8_t c)
 }
 
 SerdNode
-serd_node_new_file_uri(const uint8_t* path,
-                       const uint8_t* hostname,
-                       SerdURI*       out)
+serd_node_new_file_uri(const char* path, const char* hostname, SerdURI* out)
 {
-  const size_t path_len     = strlen((const char*)path);
-  const size_t hostname_len = hostname ? strlen((const char*)hostname) : 0;
+  const size_t path_len     = strlen(path);
+  const size_t hostname_len = hostname ? strlen(hostname) : 0;
   const bool   is_windows   = is_windows_path(path);
   size_t       uri_len      = 0;
-  uint8_t*     uri          = NULL;
+  char*        uri          = NULL;
 
   if (path[0] == '/' || is_windows) {
     uri_len = strlen("file://") + hostname_len + is_windows;
-    uri     = (uint8_t*)calloc(uri_len + 1, 1);
+    uri     = (char*)calloc(uri_len + 1, 1);
 
     memcpy(uri, "file://", 7);
 
     if (hostname) {
-      memcpy(uri + 7, hostname, hostname_len);
+      memcpy(uri + 7, hostname, hostname_len + 1);
     }
 
     if (is_windows) {
-      ((char*)uri)[7 + hostname_len] = '/';
+      uri[7 + hostname_len] = '/';
     }
   }
 
@@ -211,7 +208,7 @@ serd_node_new_file_uri(const uint8_t* path,
     } else if (is_uri_path_char(path[i])) {
       serd_buffer_sink(path + i, 1, &buffer);
     } else {
-      char escape_str[4] = {'%', 0, 0, 0};
+      char escape_str[10] = {'%', 0, 0, 0, 0, 0, 0, 0, 0, 0};
       snprintf(escape_str + 1, sizeof(escape_str) - 1, "%X", (unsigned)path[i]);
       serd_buffer_sink(escape_str, 3, &buffer);
     }
@@ -219,11 +216,11 @@ serd_node_new_file_uri(const uint8_t* path,
   serd_buffer_sink_finish(&buffer);
 
   if (out) {
-    serd_uri_parse((const uint8_t*)buffer.buf, out);
+    serd_uri_parse((const char*)buffer.buf, out);
   }
 
   return serd_node_from_substring(
-    SERD_URI, (const uint8_t*)buffer.buf, buffer.len);
+    SERD_URI, (const char*)buffer.buf, buffer.len);
 }
 
 SerdNode
@@ -235,9 +232,9 @@ serd_node_new_uri(const SerdURI* uri, const SerdURI* base, SerdURI* out)
   }
 
   const size_t len        = serd_uri_string_length(&abs_uri);
-  uint8_t*     buf        = (uint8_t*)malloc(len + 1);
+  char*        buf        = (char*)malloc(len + 1);
   SerdNode     node       = {buf, len, 0, SERD_URI};
-  uint8_t*     ptr        = buf;
+  char*        ptr        = buf;
   const size_t actual_len = serd_uri_serialise(&abs_uri, string_sink, &ptr);
 
   buf[actual_len] = '\0';
@@ -258,9 +255,9 @@ serd_node_new_relative_uri(const SerdURI* uri,
 {
   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);
+  char*        buf      = (char*)malloc(uri_len + base_len + 1);
   SerdNode     node     = {buf, 0, 0, SERD_URI};
-  uint8_t*     ptr      = buf;
+  char*        ptr      = buf;
   const size_t actual_len =
     serd_uri_serialise_relative(uri, base, root, string_sink, &ptr);
 
@@ -291,7 +288,7 @@ serd_node_new_decimal(double d, unsigned frac_digits)
   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, SERD_LITERAL};
+  SerdNode       node       = {buf, 0, 0, SERD_LITERAL};
   const double   int_part   = floor(abs_d);
 
   // Point s to decimal point location
@@ -342,7 +339,7 @@ serd_node_new_integer(int64_t i)
   uint64_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, SERD_LITERAL};
+  SerdNode       node   = {(const char*)buf, 0, 0, SERD_LITERAL};
 
   // Point s to the end
   char* s = buf + digits - 1;
@@ -366,7 +363,7 @@ 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, 0, SERD_LITERAL};
+  SerdNode     node = {(const char*)str, len, 0, SERD_LITERAL};
 
   if (serd_base64_encode(str, buf, size, wrap_lines)) {
     node.flags |= SERD_HAS_NEWLINE;
@@ -378,7 +375,7 @@ void
 serd_node_free(SerdNode* node)
 {
   if (node && node->buf) {
-    free((uint8_t*)node->buf);
+    free((char*)node->buf);
     node->buf = NULL;
   }
 }
diff --git a/src/reader.c b/src/reader.c
index 50da1979..143435c1 100644
--- a/src/reader.c
+++ b/src/reader.c
@@ -95,15 +95,15 @@ push_node_padded(SerdReader* reader,
   node->type           = type;
   node->buf            = NULL;
 
-  uint8_t* buf = (uint8_t*)(node + 1);
+  char* buf = (char*)(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[reader->n_allocs - 1] = ((char*)mem - reader->stack.buf);
 #endif
-  return (Ref)((uint8_t*)node - reader->stack.buf);
+  return (Ref)((char*)node - reader->stack.buf);
 }
 
 Ref
@@ -117,7 +117,7 @@ deref(SerdReader* reader, const Ref ref)
 {
   if (ref) {
     SerdNode* node = (SerdNode*)(reader->stack.buf + ref);
-    node->buf      = (uint8_t*)node + sizeof(SerdNode);
+    node->buf      = (char*)node + sizeof(SerdNode);
     return node;
   }
   return NULL;
@@ -133,8 +133,8 @@ pop_node(SerdReader* reader, Ref 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));
+    char* const     top  = reader->stack.buf + reader->stack.size;
+    serd_stack_pop_aligned(&reader->stack, (size_t)(top - (char*)node));
   }
   return 0;
 }
@@ -249,16 +249,16 @@ serd_reader_get_handle(const SerdReader* reader)
 }
 
 void
-serd_reader_add_blank_prefix(SerdReader* reader, const uint8_t* prefix)
+serd_reader_add_blank_prefix(SerdReader* reader, const char* prefix)
 {
   free(reader->bprefix);
   reader->bprefix_len = 0;
   reader->bprefix     = NULL;
 
-  const size_t prefix_len = prefix ? strlen((const char*)prefix) : 0;
+  const size_t prefix_len = prefix ? strlen(prefix) : 0;
   if (prefix_len) {
     reader->bprefix_len = prefix_len;
-    reader->bprefix     = (uint8_t*)malloc(reader->bprefix_len + 1);
+    reader->bprefix     = (char*)malloc(reader->bprefix_len + 1);
     memcpy(reader->bprefix, prefix, reader->bprefix_len + 1);
   }
 }
@@ -271,14 +271,14 @@ serd_reader_set_default_graph(SerdReader* reader, const SerdNode* graph)
 }
 
 SerdStatus
-serd_reader_read_file(SerdReader* reader, const uint8_t* uri)
+serd_reader_read_file(SerdReader* reader, const char* uri)
 {
-  uint8_t* const path = serd_file_uri_parse(uri, NULL);
+  char* const path = serd_file_uri_parse(uri, NULL);
   if (!path) {
     return SERD_ERR_BAD_ARG;
   }
 
-  FILE* fd = serd_fopen((const char*)path, "rb");
+  FILE* fd = serd_fopen(path, "rb");
   if (!fd) {
     serd_free(path);
     return SERD_ERR_UNKNOWN;
@@ -308,10 +308,10 @@ skip_bom(SerdReader* me)
 }
 
 SerdStatus
-serd_reader_start_stream(SerdReader*    reader,
-                         FILE*          file,
-                         const uint8_t* name,
-                         bool           bulk)
+serd_reader_start_stream(SerdReader* reader,
+                         FILE*       file,
+                         const char* name,
+                         bool        bulk)
 {
   return serd_reader_start_source_stream(reader,
                                          bulk ? (SerdSource)fread
@@ -327,7 +327,7 @@ serd_reader_start_source_stream(SerdReader*         reader,
                                 SerdSource          read_func,
                                 SerdStreamErrorFunc error_func,
                                 void*               stream,
-                                const uint8_t*      name,
+                                const char*         name,
                                 size_t              page_size)
 {
   return serd_byte_source_open_source(
@@ -373,9 +373,7 @@ serd_reader_end_stream(SerdReader* reader)
 }
 
 SerdStatus
-serd_reader_read_file_handle(SerdReader*    reader,
-                             FILE*          file,
-                             const uint8_t* name)
+serd_reader_read_file_handle(SerdReader* reader, FILE* file, const char* name)
 {
   return serd_reader_read_source(reader,
                                  (SerdSource)fread,
@@ -390,7 +388,7 @@ serd_reader_read_source(SerdReader*         reader,
                         SerdSource          source,
                         SerdStreamErrorFunc error,
                         void*               stream,
-                        const uint8_t*      name,
+                        const char*         name,
                         size_t              page_size)
 {
   SerdStatus st = serd_reader_start_source_stream(
@@ -410,7 +408,7 @@ serd_reader_read_source(SerdReader*         reader,
 }
 
 SerdStatus
-serd_reader_read_string(SerdReader* reader, const uint8_t* utf8)
+serd_reader_read_string(SerdReader* reader, const char* utf8)
 {
   serd_byte_source_open_string(&reader->source, utf8);
 
diff --git a/src/reader.h b/src/reader.h
index e5ee2810..30f3f89d 100644
--- a/src/reader.h
+++ b/src/reader.h
@@ -73,7 +73,7 @@ struct SerdReaderImpl {
   SerdSyntax        syntax;
   unsigned          next_id;
   uint8_t*          buf;
-  uint8_t*          bprefix;
+  char*             bprefix;
   size_t            bprefix_len;
   bool              strict; ///< True iff strict parsing
   bool              seen_genid;
@@ -172,11 +172,13 @@ 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);
+  char* const     s    = (char*)serd_stack_push(&reader->stack, 1);
   SerdNode* const node = (SerdNode*)(reader->stack.buf + ref);
+
+  *(uint8_t*)(s - 1) = (uint8_t)c;
+  *s                 = '\0';
+
   ++node->n_bytes;
-  *(s - 1) = (uint8_t)c;
-  *s       = '\0';
   return SERD_SUCCESS;
 }
 
diff --git a/src/serdi.c b/src/serdi.c
index 0619c5fc..26577ef6 100644
--- a/src/serdi.c
+++ b/src/serdi.c
@@ -35,7 +35,6 @@
 
 #include <errno.h>
 #include <stdbool.h>
-#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -187,24 +186,24 @@ main(int argc, char** argv)
     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;
+  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 char* in_name       = NULL;
+  const char* add_prefix    = NULL;
+  const char* chop_prefix   = NULL;
+  const char* 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_name = (const char*)"(stdin)";
       in_fd   = stdin;
       break;
     }
@@ -226,7 +225,7 @@ main(int argc, char** argv)
     } else if (argv[a][1] == 'v') {
       return print_version();
     } else if (argv[a][1] == 's') {
-      in_name   = (const uint8_t*)"(string)";
+      in_name   = (const char*)"(string)";
       from_file = false;
       ++a;
       break;
@@ -251,19 +250,19 @@ main(int argc, char** argv)
         return missing_arg(argv[0], 'p');
       }
 
-      add_prefix = (const uint8_t*)argv[a];
+      add_prefix = argv[a];
     } else if (argv[a][1] == 'c') {
       if (++a == argc) {
         return missing_arg(argv[0], 'c');
       }
 
-      chop_prefix = (const uint8_t*)argv[a];
+      chop_prefix = argv[a];
     } else if (argv[a][1] == 'r') {
       if (++a == argc) {
         return missing_arg(argv[0], 'r');
       }
 
-      root_uri = (const uint8_t*)argv[a];
+      root_uri = argv[a];
     } else {
       SERDI_ERRORF("invalid option -- '%s'\n", argv[a] + 1);
       return print_usage(argv[0], true);
@@ -280,22 +279,22 @@ main(int argc, char** argv)
   _setmode(_fileno(stdout), _O_BINARY);
 #endif
 
-  uint8_t*       input_path = NULL;
-  const uint8_t* input      = (const uint8_t*)argv[a++];
+  char*       input_path = NULL;
+  const char* input      = (const char*)argv[a++];
   if (from_file) {
     in_name = in_name ? in_name : input;
     if (!in_fd) {
-      if (!strncmp((const char*)input, "file:", 5)) {
+      if (!strncmp(input, "file:", 5)) {
         input_path = serd_file_uri_parse(input, NULL);
         input      = input_path;
       }
-      if (!input || !(in_fd = serd_fopen((const char*)input, "rb"))) {
+      if (!input || !(in_fd = serd_fopen(input, "rb"))) {
         return 1;
       }
     }
   }
 
-  if (!input_syntax && !(input_syntax = guess_syntax((const char*)in_name))) {
+  if (!input_syntax && !(input_syntax = guess_syntax(in_name))) {
     input_syntax = SERD_TRIG;
   }
 
@@ -312,8 +311,7 @@ main(int argc, char** argv)
   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);
+    base = serd_node_new_uri_from_string((const char*)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);
   }
diff --git a/src/stack.h b/src/stack.h
index fef33390..bcf1434b 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
+  char*  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. */
@@ -40,7 +40,7 @@ static inline SerdStack
 serd_stack_new(size_t size)
 {
   SerdStack stack;
-  stack.buf      = (uint8_t*)calloc(size, 1);
+  stack.buf      = (char*)calloc(size, 1);
   stack.buf_size = size;
   stack.size     = SERD_STACK_BOTTOM;
   return stack;
@@ -67,12 +67,10 @@ 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);
+    stack->buf = (char*)realloc(stack->buf, stack->buf_size);
   }
-
-  uint8_t* const ret = (stack->buf + stack->size);
-
-  stack->size = new_size;
+  char* const ret = (stack->buf + stack->size);
+  stack->size     = new_size;
   return ret;
 }
 
@@ -96,8 +94,7 @@ serd_stack_push_aligned(SerdStack* stack, size_t n_bytes, size_t align)
   }
 
   // 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;
+  stack->buf[stack->size - 1] = (char)pad;
 
   // Push requested space at aligned location
   return serd_stack_push(stack, n_bytes);
@@ -110,7 +107,7 @@ serd_stack_pop_aligned(SerdStack* stack, size_t n_bytes)
   serd_stack_pop(stack, n_bytes);
 
   // Get amount of padding from top of stack
-  const uint8_t pad = stack->buf[stack->size - 1];
+  const uint8_t pad = (uint8_t)stack->buf[stack->size - 1];
 
   // Pop padding and pad count
   serd_stack_pop(stack, pad + 1u);
diff --git a/src/string.c b/src/string.c
index defbaac4..f232acfa 100644
--- a/src/string.c
+++ b/src/string.c
@@ -20,7 +20,6 @@
 
 #include <assert.h>
 #include <math.h>
-#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -30,36 +29,36 @@ serd_free(void* ptr)
   free(ptr);
 }
 
-const uint8_t*
+const char*
 serd_strerror(SerdStatus status)
 {
   switch (status) {
   case SERD_SUCCESS:
-    return (const uint8_t*)"Success";
+    return "Success";
   case SERD_FAILURE:
-    return (const uint8_t*)"Non-fatal failure";
+    return "Non-fatal failure";
   case SERD_ERR_UNKNOWN:
-    return (const uint8_t*)"Unknown error";
+    return "Unknown error";
   case SERD_ERR_BAD_SYNTAX:
-    return (const uint8_t*)"Invalid syntax";
+    return "Invalid syntax";
   case SERD_ERR_BAD_ARG:
-    return (const uint8_t*)"Invalid argument";
+    return "Invalid argument";
   case SERD_ERR_NOT_FOUND:
-    return (const uint8_t*)"Not found";
+    return "Not found";
   case SERD_ERR_ID_CLASH:
-    return (const uint8_t*)"Blank node ID clash";
+    return "Blank node ID clash";
   case SERD_ERR_BAD_CURIE:
-    return (const uint8_t*)"Invalid CURIE";
+    return "Invalid CURIE";
   case SERD_ERR_INTERNAL:
-    return (const uint8_t*)"Internal error";
+    return "Internal error";
   default:
     break;
   }
-  return (const uint8_t*)"Unknown error"; // never reached
+  return "Unknown error"; // never reached
 }
 
 static inline void
-serd_update_flags(const uint8_t c, SerdNodeFlags* const flags)
+serd_update_flags(const char c, SerdNodeFlags* const flags)
 {
   switch (c) {
   case '\r':
@@ -74,7 +73,7 @@ serd_update_flags(const uint8_t c, SerdNodeFlags* const flags)
 }
 
 size_t
-serd_substrlen(const uint8_t* const str,
+serd_substrlen(const char* const    str,
                const size_t         len,
                SerdNodeFlags* const flags)
 {
@@ -90,7 +89,7 @@ serd_substrlen(const uint8_t* const str,
 }
 
 size_t
-serd_strlen(const uint8_t* str, SerdNodeFlags* flags)
+serd_strlen(const char* str, SerdNodeFlags* flags)
 {
   if (flags) {
     size_t i = 0;
@@ -101,7 +100,7 @@ serd_strlen(const uint8_t* str, SerdNodeFlags* flags)
     return i;
   }
 
-  return strlen((const char*)str);
+  return strlen(str);
 }
 
 static inline double
diff --git a/src/string_utils.h b/src/string_utils.h
index 60f677d0..08ba530c 100644
--- a/src/string_utils.h
+++ b/src/string_utils.h
@@ -84,20 +84,20 @@ is_print(const int c)
 }
 
 static inline bool
-is_base64(const uint8_t c)
+is_base64(const char c)
 {
   return is_alpha(c) || is_digit(c) || c == '+' || c == '/' || c == '=';
 }
 
 static inline bool
-is_windows_path(const uint8_t* path)
+is_windows_path(const char* path)
 {
   return is_alpha(path[0]) && (path[1] == ':' || path[1] == '|') &&
          (path[2] == '/' || path[2] == '\\');
 }
 
 size_t
-serd_substrlen(const uint8_t* str, size_t len, SerdNodeFlags* flags);
+serd_substrlen(const char* str, size_t len, SerdNodeFlags* flags);
 
 static inline char
 serd_to_upper(const char c)
diff --git a/src/uri.c b/src/uri.c
index baeb0fb2..93beeffe 100644
--- a/src/uri.c
+++ b/src/uri.c
@@ -25,24 +25,23 @@
 #include <stdlib.h>
 #include <string.h>
 
-uint8_t*
-serd_file_uri_parse(const uint8_t* uri, uint8_t** hostname)
+char*
+serd_file_uri_parse(const char* uri, char** hostname)
 {
-  const uint8_t* path = uri;
+  const char* path = uri;
   if (hostname) {
     *hostname = NULL;
   }
-
-  if (!strncmp((const char*)uri, "file://", 7)) {
-    const uint8_t* auth = uri + 7;
+  if (!strncmp(uri, "file://", 7)) {
+    const char* auth = uri + 7;
     if (*auth == '/') { // No hostname
       path = auth;
     } else { // Has hostname
-      if (!(path = (const uint8_t*)strchr((const char*)auth, '/'))) {
+      if (!(path = strchr(auth, '/'))) {
         return NULL;
       }
       if (hostname) {
-        *hostname = (uint8_t*)calloc((size_t)(path - auth + 1), 1);
+        *hostname = (char*)calloc((size_t)(path - auth + 1), 1);
         memcpy(*hostname, auth, (size_t)(path - auth));
       }
     }
@@ -53,14 +52,14 @@ serd_file_uri_parse(const uint8_t* uri, uint8_t** hostname)
   }
 
   SerdBuffer buffer = {NULL, 0};
-  for (const uint8_t* s = path; *s; ++s) {
+  for (const char* s = path; *s; ++s) {
     if (*s == '%') {
       if (*(s + 1) == '%') {
         serd_buffer_sink("%", 1, &buffer);
         ++s;
       } else if (is_hexdig(*(s + 1)) && is_hexdig(*(s + 2))) {
-        const uint8_t code[3] = {*(s + 1), *(s + 2), 0};
-        const uint8_t c       = (uint8_t)strtoul((const char*)code, NULL, 16);
+        const char code[3] = {*(s + 1), *(s + 2), 0};
+        const char c       = (char)strtoul((const char*)code, NULL, 16);
         serd_buffer_sink(&c, 1, &buffer);
         s += 2;
       } else {
@@ -74,14 +73,14 @@ serd_file_uri_parse(const uint8_t* uri, uint8_t** hostname)
 }
 
 bool
-serd_uri_string_has_scheme(const uint8_t* utf8)
+serd_uri_string_has_scheme(const char* 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';) {
+  for (char c = 0; (c = *++utf8) != '\0';) {
     if (!is_uri_scheme_char(c)) {
       return false;
     }
@@ -95,11 +94,11 @@ serd_uri_string_has_scheme(const uint8_t* utf8)
 }
 
 SerdStatus
-serd_uri_parse(const uint8_t* utf8, SerdURI* out)
+serd_uri_parse(const char* utf8, SerdURI* out)
 {
   *out = SERD_URI_NULL;
 
-  const uint8_t* ptr = utf8;
+  const char* ptr = utf8;
 
   /* See http://tools.ietf.org/html/rfc3986#section-3
      URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
@@ -107,7 +106,7 @@ serd_uri_parse(const uint8_t* utf8, SerdURI* out)
 
   /* S3.1: scheme ::= ALPHA *( ALPHA / DIGIT / "+" / "-" / "." ) */
   if (is_alpha(*ptr)) {
-    for (uint8_t c = *++ptr; true; c = *++ptr) {
+    for (char c = *++ptr; true; c = *++ptr) {
       switch (c) {
       case '\0':
       case '/':
@@ -139,7 +138,7 @@ maybe_authority:
   if (*ptr == '/' && *(ptr + 1) == '/') {
     ptr += 2;
     out->authority.buf = ptr;
-    for (uint8_t c = 0; (c = *ptr) != '\0'; ++ptr) {
+    for (char c = 0; (c = *ptr) != '\0'; ++ptr) {
       switch (c) {
       case '/':
         goto path;
@@ -169,7 +168,7 @@ path:
   }
   out->path.buf = ptr;
   out->path.len = 0;
-  for (uint8_t c = 0; (c = *ptr) != '\0'; ++ptr) {
+  for (char c = 0; (c = *ptr) != '\0'; ++ptr) {
     switch (c) {
     case '?':
       goto query;
@@ -187,7 +186,7 @@ path:
 query:
   if (*ptr == '?') {
     out->query.buf = ++ptr;
-    for (uint8_t c = 0; (c = *ptr) != '\0'; ++ptr) {
+    for (char c = 0; (c = *ptr) != '\0'; ++ptr) {
       if (c == '#') {
         goto fragment;
       }
@@ -217,11 +216,11 @@ end:
    @param up Set to the number of up-references (e.g. "../") trimmed
    @return A pointer to the new start of `path`
 */
-static const uint8_t*
-remove_dot_segments(const uint8_t* path, size_t len, size_t* up)
+static const char*
+remove_dot_segments(const char* path, size_t len, size_t* up)
 {
-  const uint8_t*       begin = path;
-  const uint8_t* const end   = path + len;
+  const char*       begin = path;
+  const char* const end   = path + len;
 
   *up = 0;
   while (begin < end) {
@@ -246,12 +245,12 @@ remove_dot_segments(const uint8_t* path, size_t len, size_t* up)
         }
         break;
       case '\0':
-        return ++begin; // Chop input "."
+        ++begin; // Chop input "."
+                 // fallthru
       default:
         return begin;
       }
       break;
-
     case '/':
       switch (begin[1]) {
       case '.':
@@ -269,9 +268,7 @@ remove_dot_segments(const uint8_t* path, size_t len, size_t* up)
         default:
           return begin;
         }
-      }
-      return begin;
-
+      } // else fall through
     default:
       return begin; // Finished chopping dot components
     }
@@ -284,13 +281,13 @@ remove_dot_segments(const uint8_t* path, size_t len, size_t* up)
 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;
+  size_t      up    = 0;
+  const char* begin = remove_dot_segments(path->buf, path->len, &up);
+  const char* end   = path->buf + path->len;
 
   if (base->len) {
     // Find the up'th last slash
-    const uint8_t* base_last = (base->buf + base->len - 1);
+    const char* base_last = (base->buf + base->len - 1);
     ++up;
     do {
       if (*base_last == '/') {
diff --git a/src/uri_utils.h b/src/uri_utils.h
index 2dd4924f..2544eea2 100644
--- a/src/uri_utils.h
+++ b/src/uri_utils.h
@@ -22,14 +22,12 @@
 #include "string_utils.h"
 
 #include <stdbool.h>
-#include <stdint.h>
 #include <string.h>
 
 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(a->buf, b->buf, a->len);
 }
 
 static inline size_t
@@ -38,11 +36,14 @@ uri_path_len(const SerdURI* uri)
   return uri->path_base.len + uri->path.len;
 }
 
-static inline uint8_t
+static inline char
 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];
+  if (i < uri->path_base.len) {
+    return uri->path_base.buf[i];
+  }
+
+  return uri->path.buf[i - uri->path_base.len];
 }
 
 /**
@@ -63,8 +64,8 @@ uri_rooted_index(const SerdURI* uri, const SerdURI* root)
   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);
+    const char u = uri_path_at(uri, i);
+    const char r = uri_path_at(root, i);
 
     differ = differ || u != r;
     if (r == '/') {
diff --git a/src/writer.c b/src/writer.c
index 2c483c4e..dce47599 100644
--- a/src/writer.c
+++ b/src/writer.c
@@ -106,7 +106,7 @@ struct SerdWriterImpl {
   SerdNode      list_subj;
   unsigned      list_depth;
   unsigned      indent;
-  uint8_t*      bprefix;
+  char*         bprefix;
   size_t        bprefix_len;
   Sep           last_sep;
   bool          empty;
@@ -145,7 +145,7 @@ w_err(SerdWriter* writer, SerdStatus st, const char* fmt, ...)
 
   va_list args;
   va_start(args, fmt);
-  const SerdError e = {st, (const uint8_t*)"", 0, 0, fmt, &args};
+  const SerdError e = {st, "", 0, 0, fmt, &args};
   serd_error(writer->error_sink, writer->error_handle, &e);
   va_end(args);
 }
@@ -162,7 +162,7 @@ static void
 copy_node(SerdNode* dst, const SerdNode* src)
 {
   if (src) {
-    dst->buf     = (uint8_t*)realloc((char*)dst->buf, src->n_bytes + 1);
+    dst->buf     = (char*)realloc((char*)dst->buf, src->n_bytes + 1);
     dst->n_bytes = src->n_bytes;
     dst->flags   = src->flags;
     dst->type    = src->type;
@@ -211,7 +211,7 @@ write_character(SerdWriter* writer, const uint8_t* utf8, size_t* size)
 }
 
 static inline bool
-uri_must_escape(const uint8_t c)
+uri_must_escape(const char c)
 {
   switch (c) {
   case ' ':
@@ -231,7 +231,7 @@ uri_must_escape(const uint8_t c)
 }
 
 static size_t
-write_uri(SerdWriter* writer, const uint8_t* utf8, size_t n_bytes)
+write_uri(SerdWriter* writer, const char* utf8, size_t n_bytes)
 {
   size_t len = 0;
   for (size_t i = 0; i < n_bytes;) {
@@ -250,7 +250,7 @@ write_uri(SerdWriter* writer, const uint8_t* utf8, size_t n_bytes)
 
     // Write UTF-8 character
     size_t size = 0;
-    len += write_character(writer, utf8 + i, &size);
+    len += write_character(writer, (const uint8_t*)utf8 + i, &size);
     i += size;
     if (size == 0) {
       // Corrupt input, scan to start of next character
@@ -258,12 +258,11 @@ write_uri(SerdWriter* writer, const uint8_t* utf8, size_t n_bytes)
       }
     }
   }
-
   return len;
 }
 
 static bool
-lname_must_escape(const uint8_t c)
+lname_must_escape(const char 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
@@ -300,7 +299,7 @@ lname_must_escape(const uint8_t c)
 }
 
 static size_t
-write_lname(SerdWriter* writer, const uint8_t* utf8, size_t n_bytes)
+write_lname(SerdWriter* writer, const char* utf8, size_t n_bytes)
 {
   size_t len = 0;
   for (size_t i = 0; i < n_bytes; ++i) {
@@ -326,10 +325,10 @@ write_lname(SerdWriter* writer, const uint8_t* utf8, size_t n_bytes)
 }
 
 static size_t
-write_text(SerdWriter*    writer,
-           TextContext    ctx,
-           const uint8_t* utf8,
-           size_t         n_bytes)
+write_text(SerdWriter* writer,
+           TextContext ctx,
+           const char* utf8,
+           size_t      n_bytes)
 {
   size_t len                  = 0;
   size_t n_consecutive_quotes = 0;
@@ -352,7 +351,7 @@ write_text(SerdWriter*    writer,
       break; // Reached end
     }
 
-    const uint8_t in = utf8[i++];
+    const char in = utf8[i++];
     if (ctx == WRITE_LONG_STRING) {
       n_consecutive_quotes = (in == '\"') ? (n_consecutive_quotes + 1) : 0;
 
@@ -416,7 +415,8 @@ write_text(SerdWriter*    writer,
 
     // Write UTF-8 character
     size_t size = 0;
-    len += write_character(writer, utf8 + i - 1, &size);
+    len += write_character(writer, (const uint8_t*)utf8 + i - 1, &size);
+
     if (size == 0) {
       // Corrupt input, scan to start of next character
       for (; i < n_bytes && (utf8[i] & 0x80); ++i) {
@@ -425,14 +425,13 @@ write_text(SerdWriter*    writer,
       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 char*)buf, len);
 }
 
 static void
@@ -505,7 +504,7 @@ write_literal(SerdWriter*        writer,
               SerdStatementFlags flags)
 {
   if (supports_abbrev(writer) && datatype && datatype->buf) {
-    const char* type_uri = (const char*)datatype->buf;
+    const char* type_uri = 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"))) {
@@ -515,8 +514,7 @@ write_literal(SerdWriter*        writer,
 
     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] != '.') {
+        strchr(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.
@@ -548,7 +546,7 @@ write_literal(SerdWriter*        writer,
 
 // Return true iff `buf` is a valid prefixed name suffix
 static inline bool
-is_name(const uint8_t* buf, const size_t len)
+is_name(const char* buf, const size_t len)
 {
   // TODO: This is more strict than it should be
   for (size_t i = 0; i < len; ++i) {
@@ -577,12 +575,11 @@ write_uri_node(SerdWriter* const        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")) {
+    if (field == FIELD_PREDICATE && !strcmp(node->buf, NS_RDF "type")) {
       return sink("a", 1, writer) == 1;
     }
 
-    if (!strcmp((const char*)node->buf, NS_RDF "nil")) {
+    if (!strcmp(node->buf, NS_RDF "nil")) {
       return sink("()", 2, writer) == 2;
     }
 
@@ -625,13 +622,11 @@ write_uri_node(SerdWriter* const        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;
 }
 
@@ -707,9 +702,8 @@ write_blank(SerdWriter* const        writer,
   }
 
   sink("_:", 2, writer);
-  if (writer->bprefix && !strncmp((const char*)node->buf,
-                                  (const char*)writer->bprefix,
-                                  writer->bprefix_len)) {
+  if (writer->bprefix &&
+      !strncmp(node->buf, writer->bprefix, writer->bprefix_len)) {
     sink(node->buf + writer->bprefix_len,
          node->n_bytes - writer->bprefix_len,
          writer);
@@ -772,13 +766,13 @@ write_list_obj(SerdWriter*        writer,
                const SerdNode*    datatype,
                const SerdNode*    lang)
 {
-  if (!strcmp((const char*)object->buf, NS_RDF "nil")) {
+  if (!strcmp(object->buf, NS_RDF "nil")) {
     --writer->indent;
     write_sep(writer, SEP_LIST_END);
     return true;
   }
 
-  if (!strcmp((const char*)predicate->buf, NS_RDF "first")) {
+  if (!strcmp(predicate->buf, NS_RDF "first")) {
     write_sep(writer, SEP_LIST_SEP);
     write_node(writer, object, datatype, lang, FIELD_OBJECT, flags);
   }
@@ -1000,16 +994,16 @@ 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* writer, const char* prefix)
 {
   free(writer->bprefix);
   writer->bprefix_len = 0;
   writer->bprefix     = NULL;
 
-  const size_t prefix_len = prefix ? strlen((const char*)prefix) : 0;
+  const size_t prefix_len = prefix ? strlen(prefix) : 0;
   if (prefix_len) {
     writer->bprefix_len = prefix_len;
-    writer->bprefix     = (uint8_t*)malloc(writer->bprefix_len + 1);
+    writer->bprefix     = (char*)malloc(writer->bprefix_len + 1);
     memcpy(writer->bprefix, prefix, writer->bprefix_len + 1);
   }
 }
@@ -1114,9 +1108,9 @@ serd_buffer_sink(const void* buf, size_t len, void* stream)
   return len;
 }
 
-uint8_t*
+char*
 serd_buffer_sink_finish(SerdBuffer* stream)
 {
   serd_buffer_sink("", 1, stream);
-  return (uint8_t*)stream->buf;
+  return (char*)stream->buf;
 }
diff --git a/test/test_env.c b/test/test_env.c
index b25bd9e2..7c38d481 100644
--- a/test/test_env.c
+++ b/test/test_env.c
@@ -19,11 +19,8 @@
 #include "serd/serd.h"
 
 #include <assert.h>
-#include <stdint.h>
 #include <string.h>
 
-#define USTR(s) ((const uint8_t*)(s))
-
 static SerdStatus
 count_prefixes(void* handle, const SerdNode* name, const SerdNode* uri)
 {
@@ -37,12 +34,11 @@ count_prefixes(void* handle, const SerdNode* name, const SerdNode* uri)
 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"));
+  SerdNode u   = serd_node_from_string(SERD_URI, "http://example.org/foo");
+  SerdNode b   = serd_node_from_string(SERD_CURIE, "invalid");
+  SerdNode c   = serd_node_from_string(SERD_CURIE, "eg.2:b");
   SerdEnv* env = serd_env_new(NULL);
-  serd_env_set_prefix_from_strings(
-    env, USTR("eg.2"), USTR("http://example.org/"));
+  serd_env_set_prefix_from_strings(env, "eg.2", "http://example.org/");
 
   assert(!serd_env_set_base_uri(env, NULL));
   assert(serd_env_set_base_uri(env, &SERD_NODE_NULL));
@@ -56,33 +52,32 @@ test_env(void)
   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"));
+  assert(!strcmp(xu.buf, "http://example.org/foo"));
   serd_node_free(&xu);
 
-  SerdNode badpre  = serd_node_from_string(SERD_CURIE, USTR("hm:what"));
+  SerdNode badpre  = serd_node_from_string(SERD_CURIE, "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"));
+  assert(!strcmp(xc.buf, "http://example.org/b"));
   serd_node_free(&xc);
 
   assert(serd_env_set_prefix(env, &SERD_NODE_NULL, &SERD_NODE_NULL));
 
-  const SerdNode lit = serd_node_from_string(SERD_LITERAL, USTR("hello"));
+  const SerdNode lit = serd_node_from_string(SERD_LITERAL, "hello");
   assert(serd_env_set_prefix(env, &b, &lit));
 
-  const SerdNode blank  = serd_node_from_string(SERD_BLANK, USTR("b1"));
+  const SerdNode blank  = serd_node_from_string(SERD_BLANK, "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_set_prefix_from_strings(env, "eg.2", "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 shorter_uri = serd_node_from_string(SERD_URI, "urn:foo");
   SerdNode prefix_name;
   assert(!serd_env_qualify(env, &shorter_uri, &prefix_name, &suffix));
 
diff --git a/test/test_node.c b/test/test_node.c
index d0302680..ac0a02ae 100644
--- a/test/test_node.c
+++ b/test/test_node.c
@@ -27,8 +27,6 @@
 #include <stdlib.h>
 #include <string.h>
 
-#define USTR(s) ((const uint8_t*)(s))
-
 #ifndef INFINITY
 #  define INFINITY (DBL_MAX + DBL_MAX)
 #endif
@@ -95,10 +93,10 @@ test_double_to_node(void)
   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]);
+                        ? !strcmp(node.buf, dbl_test_strs[i])
+                        : (node.buf == dbl_test_strs[i]);
     assert(pass);
-    const size_t len = node.buf ? strlen((const char*)node.buf) : 0;
+    const size_t len = node.buf ? strlen(node.buf) : 0;
     assert(node.n_bytes == len);
     serd_node_free(&node);
   }
@@ -114,9 +112,8 @@ test_integer_to_node(void)
 
   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);
+    assert(!strcmp(node.buf, int_test_strs[i]));
+    assert(node.n_bytes == strlen(node.buf));
     serd_node_free(&node);
   }
 }
@@ -132,7 +129,7 @@ test_blob_to_node(void)
 
     SerdNode blob = serd_node_new_blob(data, size, size % 5);
 
-    assert(blob.n_bytes == strlen((const char*)blob.buf));
+    assert(blob.n_bytes == strlen(blob.buf));
 
     size_t   out_size = 0;
     uint8_t* out =
@@ -153,11 +150,12 @@ 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"));
+  SerdNode      lhs =
+    serd_node_from_string(SERD_LITERAL, (const char*)replacement_char_str);
+  SerdNode rhs = serd_node_from_string(SERD_LITERAL, "123");
   assert(!serd_node_equals(&lhs, &rhs));
 
-  SerdNode qnode = serd_node_from_string(SERD_CURIE, USTR("foo:bar"));
+  SerdNode qnode = serd_node_from_string(SERD_CURIE, "foo:bar");
   assert(!serd_node_equals(&lhs, &qnode));
   assert(serd_node_equals(&lhs, &lhs));
 
@@ -168,8 +166,9 @@ test_node_equals(void)
 static void
 test_node_from_string(void)
 {
-  SerdNode node =
-    serd_node_from_string(SERD_LITERAL, (const uint8_t*)"hello\"");
+  SerdNode node = serd_node_from_string(SERD_LITERAL, "hello\"");
+  assert(node.n_bytes == 6 && node.flags == SERD_HAS_QUOTE &&
+         !strcmp(node.buf, "hello\""));
 
   assert(node.n_bytes == 6 && node.flags == SERD_HAS_QUOTE &&
          !strcmp((const char*)node.buf, "hello\""));
@@ -184,13 +183,13 @@ test_node_from_substring(void)
   SerdNode empty = serd_node_from_substring(SERD_LITERAL, NULL, 32);
   assert(!empty.buf && !empty.n_bytes && !empty.flags && !empty.type);
 
-  SerdNode a_b = serd_node_from_substring(SERD_LITERAL, USTR("a\"bc"), 3);
+  SerdNode a_b = serd_node_from_substring(SERD_LITERAL, "a\"bc", 3);
   assert(a_b.n_bytes == 3 && a_b.flags == SERD_HAS_QUOTE &&
-         !strncmp((const char*)a_b.buf, "a\"b", 3));
+         !strncmp(a_b.buf, "a\"b", 3));
 
-  a_b = serd_node_from_substring(SERD_LITERAL, USTR("a\"bc"), 10);
+  a_b = serd_node_from_substring(SERD_LITERAL, "a\"bc", 10);
   assert(a_b.n_bytes == 4 && a_b.flags == SERD_HAS_QUOTE &&
-         !strncmp((const char*)a_b.buf, "a\"bc", 4));
+         !strncmp(a_b.buf, "a\"bc", 4));
 }
 
 int
diff --git a/test/test_reader_writer.c b/test/test_reader_writer.c
index d25eb46a..35d46952 100644
--- a/test/test_reader_writer.c
+++ b/test/test_reader_writer.c
@@ -25,8 +25,6 @@
 #include <stdlib.h>
 #include <string.h>
 
-#define USTR(s) ((const uint8_t*)(s))
-
 typedef struct {
   int             n_statements;
   const SerdNode* graph;
@@ -151,10 +149,10 @@ test_read_string(void)
   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> ."));
+  const SerdStatus st =
+    serd_reader_read_string(reader,
+                            "<http://example.org/s> <http://example.org/p> "
+                            "<http://example.org/o> .");
 
   assert(!st);
   assert(rt->n_statements == 1);
@@ -173,20 +171,20 @@ test_writer(const char* const path)
     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, "tmp");
   serd_writer_chop_blank_prefix(writer, NULL);
 
-  const SerdNode lit = serd_node_from_string(SERD_LITERAL, USTR("hello"));
+  const SerdNode lit = serd_node_from_string(SERD_LITERAL, "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);
+  uint8_t  buf[] = {0xEF, 0xBF, 0xBD, 0};
+  SerdNode s     = serd_node_from_string(SERD_URI, "");
+  SerdNode p     = serd_node_from_string(SERD_URI, "http://example.org/pred");
+  SerdNode o     = serd_node_from_string(SERD_LITERAL, (char*)buf);
 
   // Write 3 invalid statements (should write nothing)
   const SerdNode* junk[][5] = {{&s, &p, &SERD_NODE_NULL, NULL, NULL},
@@ -206,8 +204,8 @@ test_writer(const char* const path)
                                        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  t         = serd_node_from_string(SERD_URI, "urn:Type");
+  const SerdNode  l         = serd_node_from_string(SERD_LITERAL, "en");
   const SerdNode* good[][5] = {{&s, &p, &o, NULL, NULL},
                                {&s, &p, &o, &SERD_NODE_NULL, &SERD_NODE_NULL},
                                {&s, &p, &o, &t, NULL},
@@ -231,15 +229,15 @@ test_writer(const char* const path)
 
   // 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);
+  SerdNode bad_lit = serd_node_from_string(SERD_LITERAL, (const char*)bad_str);
+  SerdNode bad_uri = serd_node_from_string(SERD_URI, (const char*)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"));
+  o = serd_node_from_string(SERD_LITERAL, "hello");
   assert(!serd_writer_write_statement(writer, 0, NULL, &s, &p, &o, NULL, NULL));
 
   serd_writer_free(writer);
@@ -249,17 +247,17 @@ test_writer(const char* const path)
   writer            = serd_writer_new(
     SERD_TURTLE, (SerdStyle)0, env, NULL, serd_buffer_sink, &buffer);
 
-  o = serd_node_from_string(SERD_URI, USTR("http://example.org/base"));
+  o = serd_node_from_string(SERD_URI, "http://example.org/base");
   assert(!serd_writer_set_base_uri(writer, &o));
 
   serd_writer_free(writer);
-  uint8_t* out = serd_buffer_sink_finish(&buffer);
+  char* out = serd_buffer_sink_finish(&buffer);
 
-  assert(!strcmp((const char*)out, "@base <http://example.org/base> .\n"));
+  assert(!strcmp(out, "@base <http://example.org/base> .\n"));
   serd_free(out);
 
   // Test writing empty node
-  SerdNode    nothing = serd_node_from_string(SERD_NOTHING, USTR(""));
+  SerdNode    nothing = serd_node_from_string(SERD_NOTHING, "");
   FILE* const empty   = tmpfile();
 
   writer = serd_writer_new(
@@ -286,9 +284,9 @@ test_reader(const char* path)
   assert(reader);
   assert(serd_reader_get_handle(reader) == rt);
 
-  SerdNode g = serd_node_from_string(SERD_URI, USTR("http://example.org/"));
+  SerdNode g = serd_node_from_string(SERD_URI, "http://example.org/");
   serd_reader_set_default_graph(reader, &g);
-  serd_reader_add_blank_prefix(reader, USTR("tmp"));
+  serd_reader_add_blank_prefix(reader, "tmp");
 
 #if defined(__GNUC__)
 #  pragma GCC diagnostic push
@@ -299,17 +297,17 @@ test_reader(const char* path)
 #  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://")));
+  assert(serd_reader_read_file(reader, "http://notafile"));
+  assert(serd_reader_read_file(reader, "file:///better/not/exist"));
+  assert(serd_reader_read_file(reader, "file://"));
 
-  const SerdStatus st = serd_reader_read_file(reader, USTR(path));
+  const SerdStatus st = serd_reader_read_file(reader, path);
   assert(!st);
   assert(rt->n_statements == 13);
   assert(rt->graph && rt->graph->buf &&
-         !strcmp((const char*)rt->graph->buf, "http://example.org/"));
+         !strcmp(rt->graph->buf, "http://example.org/"));
 
-  assert(serd_reader_read_string(reader, USTR("This isn't Turtle at all.")));
+  assert(serd_reader_read_string(reader, "This isn't Turtle at all."));
 
   // A read of a big page hits EOF then fails to read chunks immediately
   {
diff --git a/test/test_string.c b/test/test_string.c
index 27a488fb..842ff3df 100644
--- a/test/test_string.c
+++ b/test/test_string.c
@@ -29,23 +29,23 @@ test_strlen(void)
   const uint8_t str[] = {'"', '5', 0xE2, 0x82, 0xAC, '"', '\n', 0};
 
   SerdNodeFlags flags   = 0;
-  size_t        n_bytes = serd_strlen(str, &flags);
+  size_t        n_bytes = serd_strlen((const char*)str, &flags);
   assert(n_bytes == 7 && flags == (SERD_HAS_QUOTE | SERD_HAS_NEWLINE));
-  assert(serd_strlen(str, NULL) == 7);
+  assert(serd_strlen((const char*)str, NULL) == 7);
 }
 
 static void
 test_strerror(void)
 {
-  const uint8_t* msg = serd_strerror(SERD_SUCCESS);
-  assert(!strcmp((const char*)msg, "Success"));
+  const char* msg = serd_strerror(SERD_SUCCESS);
+  assert(!strcmp(msg, "Success"));
   for (int i = SERD_FAILURE; i <= SERD_ERR_INTERNAL; ++i) {
     msg = serd_strerror((SerdStatus)i);
-    assert(strcmp((const char*)msg, "Success"));
+    assert(strcmp(msg, "Success"));
   }
 
   msg = serd_strerror((SerdStatus)-1);
-  assert(!strcmp((const char*)msg, "Unknown error"));
+  assert(!strcmp(msg, "Unknown error"));
 }
 
 int
diff --git a/test/test_uri.c b/test/test_uri.c
index 554b4a93..8c3ec5a4 100644
--- a/test/test_uri.c
+++ b/test/test_uri.c
@@ -19,12 +19,9 @@
 #include "serd/serd.h"
 
 #include <assert.h>
-#include <stdint.h>
 #include <stdio.h>
 #include <string.h>
 
-#define USTR(s) ((const uint8_t*)(s))
-
 static void
 test_file_uri(const char* hostname,
               const char* path,
@@ -35,13 +32,12 @@ test_file_uri(const char* hostname,
     expected_path = path;
   }
 
-  SerdNode node = serd_node_new_file_uri(USTR(path), USTR(hostname), 0);
-
-  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));
+  SerdNode node         = serd_node_new_file_uri(path, hostname, 0);
+  char*    out_hostname = NULL;
+  char*    out_path     = serd_file_uri_parse(node.buf, &out_hostname);
+  assert(!strcmp(node.buf, expected_uri));
   assert((hostname && out_hostname) || (!hostname && !out_hostname));
-  assert(!strcmp((const char*)out_path, (const char*)expected_path));
+  assert(!strcmp(out_path, expected_path));
 
   serd_free(out_path);
   serd_free(out_hostname);
@@ -62,8 +58,8 @@ test_uri_parsing(void)
 
   // 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"));
+  char* out_path = serd_file_uri_parse("file:///foo/%0Xbar", NULL);
+  assert(!strcmp(out_path, "/foo/bar"));
   serd_free(out_path);
 }
 
@@ -75,13 +71,13 @@ test_uri_from_string(void)
 
   SerdURI  base_uri;
   SerdNode base =
-    serd_node_new_uri_from_string(USTR("http://example.org/"), NULL, &base_uri);
+    serd_node_new_uri_from_string("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);
+  SerdNode nil2 = serd_node_new_uri_from_string("", &base_uri, NULL);
   assert(nil.type == SERD_URI);
-  assert(!strcmp((const char*)nil.buf, (const char*)base.buf));
+  assert(!strcmp(nil.buf, base.buf));
   assert(nil2.type == SERD_URI);
-  assert(!strcmp((const char*)nil2.buf, (const char*)base.buf));
+  assert(!strcmp(nil2.buf, base.buf));
   serd_node_free(&nil);
   serd_node_free(&nil2);
 
@@ -93,32 +89,30 @@ test_relative_uri(void)
 {
   SerdURI  base_uri;
   SerdNode base =
-    serd_node_new_uri_from_string(USTR("http://example.org/"), NULL, &base_uri);
+    serd_node_new_uri_from_string("http://example.org/", NULL, &base_uri);
 
-  SerdNode abs =
-    serd_node_from_string(SERD_URI, USTR("http://example.org/foo/bar"));
-  SerdURI abs_uri;
+  SerdNode abs = serd_node_from_string(SERD_URI, "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"));
+  assert(!strcmp(rel.buf, "/foo/bar"));
 
   SerdNode up = serd_node_new_relative_uri(&base_uri, &abs_uri, NULL, NULL);
-  assert(!strcmp((const char*)up.buf, "../"));
+  assert(!strcmp(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/"));
+  assert(!strcmp(noup.buf, "http://example.org/"));
 
-  SerdNode x =
-    serd_node_from_string(SERD_URI, USTR("http://example.org/foo/x"));
-  SerdURI x_uri;
+  SerdNode x = serd_node_from_string(SERD_URI, "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"));
+  assert(!strcmp(x_rel.buf, "x"));
 
   serd_node_free(&x_rel);
   serd_node_free(&noup);