Use char* for strings in public API

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

1 files changed, 29 insertions, 30 deletions

diff --git a/src/node.c b/src/node.c
index c8fba903..229f7902 100644
--- a/src/node.c
+++ b/src/node.c
@@ -60,14 +60,14 @@ serd_uri_string_length(const SerdURI* const uri)
 static size_t
 string_sink(const void* const buf, const size_t len, void* const stream)
 {
-  uint8_t** ptr = (uint8_t**)stream;
+  char** ptr = (char**)stream;
   memcpy(*ptr, buf, len);
   *ptr += len;
   return len;
 }
 
 SerdNode
-serd_node_from_string(const SerdType type, const uint8_t* const str)
+serd_node_from_string(SerdType type, const char* const str)
 {
   if (!str) {
     return SERD_NODE_NULL;
@@ -80,9 +80,9 @@ serd_node_from_string(const SerdType type, const uint8_t* const str)
 }
 
 SerdNode
-serd_node_from_substring(const SerdType       type,
-                         const uint8_t* const str,
-                         const size_t         len)
+serd_node_from_substring(const SerdType    type,
+                         const char* const str,
+                         const size_t      len)
 {
   if (!str) {
     return SERD_NODE_NULL;
@@ -102,7 +102,7 @@ serd_node_copy(const SerdNode* const 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;
@@ -113,8 +113,7 @@ serd_node_equals(const SerdNode* const a, const SerdNode* const 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)));
 }
 
 SerdNode
@@ -128,7 +127,7 @@ serd_node_new_uri_from_node(const SerdNode* const uri_node,
 }
 
 SerdNode
-serd_node_new_uri_from_string(const uint8_t* const str,
+serd_node_new_uri_from_string(const char* const    str,
                               const SerdURI* const base,
                               SerdURI* const       out)
 {
@@ -143,7 +142,7 @@ serd_node_new_uri_from_string(const uint8_t* const str,
 }
 
 static 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;
@@ -179,28 +178,28 @@ is_uri_path_char(const uint8_t c)
 }
 
 SerdNode
-serd_node_new_file_uri(const uint8_t* const path,
-                       const uint8_t* const hostname,
-                       SerdURI* const       out)
+serd_node_new_file_uri(const char* const path,
+                       const char* const hostname,
+                       SerdURI* const    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] = '/';
     }
   }
 
@@ -213,7 +212,7 @@ serd_node_new_file_uri(const uint8_t* const 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);
     }
@@ -221,11 +220,11 @@ serd_node_new_file_uri(const uint8_t* const 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
@@ -239,9 +238,9 @@ serd_node_new_uri(const SerdURI* const uri,
   }
 
   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';
@@ -262,9 +261,9 @@ serd_node_new_relative_uri(const SerdURI* const 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);
 
@@ -295,7 +294,7 @@ serd_node_new_decimal(const double d, const 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
@@ -346,7 +345,7 @@ serd_node_new_integer(const 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;
@@ -372,7 +371,7 @@ serd_node_new_blob(const void* const buf,
 {
   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;
@@ -384,7 +383,7 @@ void
 serd_node_free(SerdNode* const node)
 {
   if (node && node->buf) {
-    free((uint8_t*)node->buf);
+    free((char*)node->buf);
     node->buf = NULL;
   }
 }