From 085e63e53502adfc16c3830ed6b0b941314b8f8a Mon Sep 17 00:00:00 2001 From: David Robillard Date: Wed, 16 Mar 2016 16:21:20 -0400 Subject: Use char* for strings in public API The constant casting just makes user code a mess, for no benefit. --- NEWS | 1 + serd/serd.h | 90 ++++++++++++++--------------- src/base64.c | 10 ++-- src/byte_sink.h | 6 +- src/byte_source.c | 8 +-- src/byte_source.h | 10 ++-- src/env.c | 21 +++---- src/n3.c | 4 +- src/node.c | 61 ++++++++++---------- src/reader.c | 48 ++++++++-------- src/reader.h | 4 +- src/serdi.c | 27 +++++---- src/stack.h | 13 ++--- src/string.c | 31 +++++----- src/string_utils.h | 6 +- src/uri.c | 64 ++++++++++----------- src/uri_utils.h | 9 ++- src/writer.c | 54 +++++++++--------- tests/env_test.c | 25 ++++---- tests/serd_test.c | 165 ++++++++++++++++++++++++++--------------------------- 20 files changed, 321 insertions(+), 336 deletions(-) diff --git a/NEWS b/NEWS index 4102a408..95c20ea9 100644 --- a/NEWS +++ b/NEWS @@ -2,6 +2,7 @@ serd (1.0.1) unstable; * Add SerdBuffer for mutable buffers to keep SerdChunk const-correct * Remove useless character counting from API + * Use char* for strings in public API -- David Robillard Sat, 19 Jan 2019 12:31:12 +0000 diff --git a/serd/serd.h b/serd/serd.h index ca133b96..adb0f476 100644 --- a/serd/serd.h +++ b/serd/serd.h @@ -218,7 +218,7 @@ typedef uint32_t SerdNodeFlags; A syntactic RDF node. */ typedef struct { - const uint8_t* buf; /**< Value string */ + const char* buf; /**< Value string */ size_t n_bytes; /**< Size in bytes (not including null) */ SerdNodeFlags flags; /**< Node flags (e.g. string properties) */ SerdType type; /**< Node type */ @@ -228,8 +228,8 @@ typedef struct { An unterminated string fragment. */ typedef struct { - const uint8_t* buf; /**< Start of chunk */ - size_t len; /**< Length of chunk in bytes */ + const char* buf; /**< Start of chunk */ + size_t len; /**< Length of chunk in bytes */ } SerdChunk; /** @@ -244,12 +244,12 @@ typedef struct { An error description. */ typedef struct { - SerdStatus status; /**< Error code */ - const uint8_t* filename; /**< File where error was encountered, or NULL */ - unsigned line; /**< Line where error was encountered, or 0 */ - unsigned col; /**< Column where error was encountered */ - const char* fmt; /**< Message format string (printf style) */ - va_list* args; /**< Arguments for fmt */ + SerdStatus status; /**< Error code */ + const char* filename; /**< File where error was encountered, or NULL */ + unsigned line; /**< Line where error was encountered, or 0 */ + unsigned col; /**< Column where error was encountered */ + const char* fmt; /**< Message format string (printf style) */ + va_list* args; /**< Arguments for fmt */ } SerdError; /** @@ -304,7 +304,7 @@ serd_free(void* ptr); Return a string describing a status code. */ SERD_API -const uint8_t* +const char* serd_strerror(SerdStatus status); /** @@ -315,7 +315,7 @@ serd_strerror(SerdStatus status); */ SERD_API size_t -serd_strlen(const uint8_t* str, SerdNodeFlags* flags); +serd_strlen(const char* str, SerdNodeFlags* flags); /** Parse a string to a double. @@ -340,7 +340,7 @@ serd_strtod(const char* str, char** endptr); */ SERD_API 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); /** @} @@ -397,8 +397,8 @@ static const SerdURI SERD_URI_NULL = { a path, use serd_file_uri_parse(). */ SERD_API -const uint8_t* -serd_uri_to_path(const uint8_t* uri); +const char* +serd_uri_to_path(const char* uri); /** Get the unescaped path and hostname from a file URI. @@ -409,22 +409,22 @@ serd_uri_to_path(const uint8_t* uri); The returned path and `*hostname` must be freed with serd_free(). */ SERD_API -uint8_t* -serd_file_uri_parse(const uint8_t* uri, uint8_t** hostname); +char* +serd_file_uri_parse(const char* uri, char** hostname); /** Return true iff `utf8` starts with a valid URI scheme. */ SERD_API bool -serd_uri_string_has_scheme(const uint8_t* utf8); +serd_uri_string_has_scheme(const char* utf8); /** Parse `utf8`, writing result to `out`. */ SERD_API SerdStatus -serd_uri_parse(const uint8_t* utf8, SerdURI* out); +serd_uri_parse(const char* utf8, SerdURI* out); /** Set target `t` to reference `r` resolved against `base`. @@ -472,7 +472,7 @@ static const SerdNode SERD_NODE_NULL = { NULL, 0, 0, SERD_NOTHING }; */ SERD_API SerdNode -serd_node_from_string(SerdType type, const uint8_t* str); +serd_node_from_string(SerdType type, const char* str); /** Make a (shallow) node from a prefix of `str`. @@ -482,7 +482,7 @@ serd_node_from_string(SerdType type, const uint8_t* str); */ SERD_API SerdNode -serd_node_from_substring(SerdType type, const uint8_t* str, size_t len); +serd_node_from_substring(SerdType type, const char* str, size_t len); /** Simple wrapper for serd_node_new_uri() to resolve a URI node. @@ -498,7 +498,7 @@ serd_node_new_uri_from_node(const SerdNode* uri_node, */ SERD_API 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); @@ -514,10 +514,10 @@ serd_node_new_uri_from_string(const uint8_t* str, */ SERD_API SerdNode -serd_node_new_file_uri(const uint8_t* path, - const uint8_t* hostname, - SerdURI* out, - bool escape); +serd_node_new_file_uri(const char* path, + const char* hostname, + SerdURI* out, + bool escape); /** Create a new node by serialising `uri` into a new string. @@ -723,9 +723,9 @@ serd_env_set_prefix(SerdEnv* env, */ SERD_API 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); /** Qualify `uri` into a CURIE if possible. @@ -829,8 +829,8 @@ serd_reader_get_handle(const SerdReader* reader); */ SERD_API void -serd_reader_add_blank_prefix(SerdReader* reader, - const uint8_t* prefix); +serd_reader_add_blank_prefix(SerdReader* reader, + const char* prefix); /** Set the URI of the default graph. @@ -849,8 +849,8 @@ serd_reader_set_default_graph(SerdReader* reader, */ SERD_API SerdStatus -serd_reader_read_file(SerdReader* reader, - const uint8_t* uri); +serd_reader_read_file(SerdReader* reader, + const char* uri); /** Start an incremental read from a file handle. @@ -862,10 +862,10 @@ serd_reader_read_file(SerdReader* reader, */ SERD_API 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); /** Start an incremental read from a user-specified source. @@ -879,7 +879,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); /** @@ -906,9 +906,9 @@ serd_reader_end_stream(SerdReader* reader); */ SERD_API 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); /** Read a user-specified byte source. @@ -919,7 +919,7 @@ serd_reader_read_source(SerdReader* reader, SerdSource source, SerdStreamErrorFunc error, void* stream, - const uint8_t* name, + const char* name, size_t page_size); /** @@ -927,7 +927,7 @@ serd_reader_read_source(SerdReader* reader, */ SERD_API SerdStatus -serd_reader_read_string(SerdReader* reader, const uint8_t* utf8); +serd_reader_read_string(SerdReader* reader, const char* utf8); /** Free `reader`. @@ -997,7 +997,7 @@ serd_buffer_sink(const void* buf, size_t len, void* stream); terminated (by this function) and owned by the caller. */ SERD_API -uint8_t* +char* serd_buffer_sink_finish(SerdBuffer* stream); /** @@ -1017,8 +1017,8 @@ serd_writer_set_error_sink(SerdWriter* writer, */ SERD_API void -serd_writer_chop_blank_prefix(SerdWriter* writer, - const uint8_t* prefix); +serd_writer_chop_blank_prefix(SerdWriter* writer, + const char* prefix); /** Set the current output base URI (and emit directive if applicable). diff --git a/src/base64.c b/src/base64.c index 763c2d2e..884d0a48 100644 --- a/src/base64.c +++ b/src/base64.c @@ -71,7 +71,7 @@ serd_base64_encode(uint8_t* const str, const size_t size, const bool wrap_lines) { - bool has_newline = false; + 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); @@ -105,16 +105,18 @@ 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) { + const uint8_t* const ustr = (const uint8_t*)str; + 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); diff --git a/src/byte_sink.h b/src/byte_sink.h index f39bc2ba..f9b8a12a 100644 --- a/src/byte_sink.h +++ b/src/byte_sink.h @@ -28,7 +28,7 @@ typedef struct SerdByteSinkImpl { SerdSink sink; void* stream; - uint8_t* buf; + char* buf; size_t size; size_t block_size; } SerdByteSink; @@ -42,7 +42,7 @@ serd_byte_sink_new(SerdSink sink, void* stream, size_t block_size) bsink.size = 0; bsink.block_size = block_size; bsink.buf = ((block_size > 1) - ? (uint8_t*)serd_bufalloc(block_size) + ? (char*)serd_bufalloc(block_size) : NULL); return bsink; } @@ -81,7 +81,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 diff --git a/src/byte_source.c b/src/byte_source.c index d783959c..8006fcf5 100644 --- a/src/byte_source.c +++ b/src/byte_source.c @@ -48,7 +48,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 }; @@ -88,13 +88,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 a0dfa140..e5c4a8bf 100644 --- a/src/byte_source.h +++ b/src/byte_source.h @@ -26,9 +26,9 @@ #include typedef struct { - const uint8_t* filename; - unsigned line; - unsigned col; + const char* filename; + unsigned line; + unsigned col; } Cursor; typedef struct { @@ -53,14 +53,14 @@ serd_byte_source_open_file(SerdByteSource* source, 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 5c260f30..3bdd65c3 100644 --- a/src/env.c +++ b/src/env.c @@ -17,7 +17,6 @@ #include "serd/serd.h" #include -#include #include #include #include @@ -95,7 +94,7 @@ serd_env_set_base_uri(SerdEnv* env, static inline SerdPrefix* serd_env_find(const SerdEnv* env, - const uint8_t* name, + const char* name, size_t name_len) { for (size_t i = 0; i < env->n_prefixes; ++i) { @@ -153,9 +152,9 @@ serd_env_set_prefix(SerdEnv* env, } 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); @@ -172,10 +171,8 @@ 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)) { - *prefix = env->prefixes[i].name; + 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; return true; @@ -191,7 +188,7 @@ serd_env_expand(const SerdEnv* env, SerdChunk* uri_prefix, SerdChunk* uri_suffix) { - const uint8_t* const colon = (const uint8_t*)memchr( + const char* const colon = (const char*)memchr( curie->buf, ':', curie->n_bytes + 1); if (curie->type != SERD_CURIE || !colon) { return SERD_ERR_BAD_ARG; @@ -228,9 +225,9 @@ serd_env_expand_node(const SerdEnv* env, 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 2e85ea66..fcd78bc3 100644 --- a/src/n3.c +++ b/src/n3.c @@ -924,7 +924,7 @@ read_BLANK_NODE_LABEL(SerdReader* reader, Ref* dest, bool* ate_dot) const Ref ref = *dest = push_node(reader, SERD_BLANK, - reader->bprefix ? (char*)reader->bprefix : "", + reader->bprefix ? reader->bprefix : "", reader->bprefix_len); int c = peek_byte(reader); // First: (PN_CHARS | '_' | [0-9]) @@ -1459,7 +1459,7 @@ tokcmp(SerdReader* reader, Ref ref, const char* tok, size_t n) if (!node || node->n_bytes != 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 dac03b55..7ad3523a 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; @@ -84,9 +84,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 +107,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 +124,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 +139,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; @@ -160,23 +158,22 @@ is_uri_path_char(const uint8_t c) } SerdNode -serd_node_new_file_uri(const uint8_t* path, - const uint8_t* hostname, - SerdURI* out, - bool escape) +serd_node_new_file_uri(const char* path, + const char* hostname, + SerdURI* out, + bool escape) { - const size_t path_len = strlen((const char*)path); - const size_t hostname_len = hostname ? strlen((const char*)hostname) : 0; + const size_t path_len = strlen(path); + const size_t hostname_len = hostname ? strlen(hostname) : 0; const bool evil = is_windows_path(path); size_t uri_len = 0; - uint8_t* uri = NULL; + char* uri = NULL; if (path[0] == '/' || is_windows_path(path)) { uri_len = strlen("file://") + hostname_len + evil; - uri = (uint8_t*)malloc(uri_len + 1); - snprintf((char*)uri, uri_len + 1, "file://%s%s", - hostname ? (const char*)hostname : "", - evil ? "/" : ""); + uri = (char*)malloc(uri_len + 1); + snprintf(uri, uri_len + 1, "file://%s%s", + hostname ? hostname : "", evil ? "/" : ""); } SerdBuffer buffer = { uri, uri_len }; @@ -199,11 +196,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 @@ -215,9 +212,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'; @@ -236,11 +233,11 @@ serd_node_new_relative_uri(const SerdURI* uri, const SerdURI* root, SerdURI* out) { - const size_t uri_len = serd_uri_string_length(uri); - const size_t base_len = serd_uri_string_length(base); - uint8_t* buf = (uint8_t*)malloc(uri_len + base_len + 1); + const size_t uri_len = serd_uri_string_length(uri); + const size_t base_len = serd_uri_string_length(base); + 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); @@ -271,7 +268,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 @@ -321,7 +318,7 @@ serd_node_new_integer(int64_t i) int64_t abs_i = (i < 0) ? -i : i; const unsigned digits = serd_digits((double)abs_i); char* buf = (char*)calloc(digits + 2, 1); - SerdNode node = { (const uint8_t*)buf, 0, 0, SERD_LITERAL }; + SerdNode node = { (const char*)buf, 0, 0, SERD_LITERAL }; // Point s to the end char* s = buf + digits - 1; @@ -345,7 +342,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; @@ -357,7 +354,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 6da29ab1..11ce520d 100644 --- a/src/reader.c +++ b/src/reader.c @@ -90,15 +90,15 @@ push_node_padded(SerdReader* reader, size_t maxlen, 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] = (mem - reader->stack.buf); #endif - return (Ref)((uint8_t*)node - reader->stack.buf); + return (Ref)((char*)node - reader->stack.buf); } Ref @@ -112,7 +112,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; @@ -128,8 +128,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; } @@ -245,15 +245,15 @@ 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; if (prefix) { - reader->bprefix_len = strlen((const char*)prefix); - reader->bprefix = (uint8_t*)malloc(reader->bprefix_len + 1); + reader->bprefix_len = strlen(prefix); + reader->bprefix = (char*)malloc(reader->bprefix_len + 1); memcpy(reader->bprefix, prefix, reader->bprefix_len + 1); } } @@ -267,15 +267,15 @@ serd_reader_set_default_graph(SerdReader* reader, } 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; @@ -305,10 +305,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, @@ -324,7 +324,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( @@ -370,9 +370,9 @@ 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, (SerdStreamErrorFunc)ferror, @@ -384,7 +384,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( @@ -402,7 +402,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 684bceb2..19e27993 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; @@ -162,7 +162,7 @@ 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); ++node->n_bytes; *(s - 1) = (uint8_t)c; diff --git a/src/serdi.c b/src/serdi.c index ab69b770..ed87bdfd 100644 --- a/src/serdi.c +++ b/src/serdi.c @@ -32,7 +32,6 @@ #include #include -#include #include #include @@ -163,14 +162,14 @@ main(int argc, char** argv) 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; + 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; } else if (argv[a][1] == 'a') { @@ -190,7 +189,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; @@ -210,17 +209,17 @@ main(int argc, char** argv) if (++a == argc) { 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); @@ -237,18 +236,18 @@ main(int argc, char** argv) _setmode(_fileno(stdout), _O_BINARY); #endif - const uint8_t* input = (const uint8_t*)argv[a++]; + const char* input = (const char*)argv[a++]; if (from_file) { in_name = in_name ? in_name : input; if (!in_fd) { input = serd_uri_to_path(in_name); - 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; } @@ -263,7 +262,7 @@ main(int argc, char** argv) 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); + (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, true); } diff --git a/src/stack.h b/src/stack.h index 9c1d075a..8943370c 100644 --- a/src/stack.h +++ b/src/stack.h @@ -28,7 +28,7 @@ /** A dynamic stack in memory. */ typedef struct { - uint8_t* buf; ///< Stack memory + char* buf; ///< Stack memory size_t buf_size; ///< Allocated size of buf (>= size) size_t size; ///< Conceptual size of stack in buf } SerdStack; @@ -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,9 +67,9 @@ 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); + char* const ret = (stack->buf + stack->size); stack->size = new_size; return ret; } @@ -94,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); @@ -108,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 485d3945..3f068a1d 100644 --- a/src/string.c +++ b/src/string.c @@ -20,7 +20,6 @@ #include #include -#include #include #include @@ -30,26 +29,26 @@ 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"; - case SERD_FAILURE: return (const uint8_t*)"Non-fatal failure"; - case SERD_ERR_UNKNOWN: return (const uint8_t*)"Unknown error"; - case SERD_ERR_BAD_SYNTAX: return (const uint8_t*)"Invalid syntax"; - case SERD_ERR_BAD_ARG: return (const uint8_t*)"Invalid argument"; - case SERD_ERR_NOT_FOUND: return (const uint8_t*)"Not found"; - case SERD_ERR_ID_CLASH: return (const uint8_t*)"Blank node ID clash"; - case SERD_ERR_BAD_CURIE: return (const uint8_t*)"Invalid CURIE"; - case SERD_ERR_INTERNAL: return (const uint8_t*)"Internal error"; + case SERD_SUCCESS: return "Success"; + case SERD_FAILURE: return "Non-fatal failure"; + case SERD_ERR_UNKNOWN: return "Unknown error"; + case SERD_ERR_BAD_SYNTAX: return "Invalid syntax"; + case SERD_ERR_BAD_ARG: return "Invalid argument"; + case SERD_ERR_NOT_FOUND: return "Not found"; + case SERD_ERR_ID_CLASH: return "Blank node ID clash"; + case SERD_ERR_BAD_CURIE: return "Invalid CURIE"; + case SERD_ERR_INTERNAL: 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': case '\n': @@ -63,7 +62,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) { @@ -79,7 +78,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; @@ -90,7 +89,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 fd86b0c9..7bbfd2b3 100644 --- a/src/string_utils.h +++ b/src/string_utils.h @@ -75,20 +75,20 @@ is_space(const char 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 int serd_strncasecmp(const char* s1, const char* s2, size_t n) diff --git a/src/uri.c b/src/uri.c index 9b23b959..1d46ab20 100644 --- a/src/uri.c +++ b/src/uri.c @@ -25,17 +25,17 @@ #include #include -const uint8_t* -serd_uri_to_path(const uint8_t* uri) +const char* +serd_uri_to_path(const char* uri) { - const uint8_t* path = uri; + const char* path = uri; if (!is_windows_path(uri) && serd_uri_string_has_scheme(uri)) { - if (strncmp((const char*)uri, "file:", 5)) { + if (strncmp(uri, "file:", 5)) { fprintf(stderr, "Non-file URI `%s'\n", uri); return NULL; - } else if (!strncmp((const char*)uri, "file://localhost/", 17)) { + } else if (!strncmp(uri, "file://localhost/", 17)) { path = uri + 16; - } else if (!strncmp((const char*)uri, "file://", 7)) { + } else if (!strncmp(uri, "file://", 7)) { path = uri + 7; } else { fprintf(stderr, "Invalid file URI `%s'\n", uri); @@ -48,23 +48,23 @@ serd_uri_to_path(const uint8_t* uri) return path; } -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)); } } @@ -75,14 +75,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 { @@ -96,14 +96,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; } else if (c == ':') { @@ -115,11 +115,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 ] @@ -127,7 +127,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 '/': case '?': case '#': ptr = utf8; @@ -154,7 +154,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; case '?': goto query; @@ -177,7 +177,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; case '#': goto fragment; @@ -193,7 +193,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; } @@ -223,11 +223,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) { @@ -288,13 +288,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 4dbcdba5..28d74be4 100644 --- a/src/uri_utils.h +++ b/src/uri_utils.h @@ -24,8 +24,7 @@ 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 @@ -34,7 +33,7 @@ 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) { if (i < uri->path_base.len) { @@ -62,8 +61,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 96d2e92b..39acd75b 100644 --- a/src/writer.c +++ b/src/writer.c @@ -110,7 +110,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; @@ -146,7 +146,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); } @@ -163,7 +163,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; @@ -212,7 +212,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 ' ': case '"': case '<': case '>': case '\\': @@ -224,7 +224,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;) { @@ -243,7 +243,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 @@ -254,7 +254,7 @@ write_uri(SerdWriter* writer, const uint8_t* utf8, size_t n_bytes) } 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 @@ -277,7 +277,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) { @@ -303,7 +303,7 @@ 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) + const char* utf8, size_t n_bytes) { size_t len = 0; for (size_t i = 0; i < n_bytes;) { @@ -358,7 +358,8 @@ write_text(SerdWriter* writer, TextContext ctx, // 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) {} @@ -372,7 +373,7 @@ write_text(SerdWriter* writer, TextContext ctx, 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 @@ -441,7 +442,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"))) { @@ -449,7 +450,7 @@ write_literal(SerdWriter* writer, return true; } else if (!strncmp(type_uri, NS_XSD, sizeof(NS_XSD) - 1) && !strcmp(type_uri + sizeof(NS_XSD) - 1, "decimal") && - strchr((const char*)node->buf, '.') && + 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 @@ -482,7 +483,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) { @@ -510,10 +511,10 @@ write_uri_node(SerdWriter* const writer, const bool has_scheme = serd_uri_string_has_scheme(node->buf); if (field == FIELD_PREDICATE && supports_abbrev(writer) - && !strcmp((const char*)node->buf, NS_RDF "type")) { + && !strcmp(node->buf, NS_RDF "type")) { return sink("a", 1, writer) == 1; } else if (supports_abbrev(writer) - && !strcmp((const char*)node->buf, NS_RDF "nil")) { + && !strcmp(node->buf, NS_RDF "nil")) { return sink("()", 2, writer) == 2; } else if (has_scheme && (writer->style & SERD_STYLE_CURIED) && serd_env_qualify(writer->env, node, &prefix, &suffix) && @@ -618,9 +619,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); @@ -682,11 +682,11 @@ 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; - } else if (!strcmp((const char*)predicate->buf, NS_RDF "first")) { + } else if (!strcmp(predicate->buf, NS_RDF "first")) { write_sep(writer, SEP_LIST_SEP); write_node(writer, object, datatype, lang, FIELD_OBJECT, flags); } @@ -901,15 +901,15 @@ 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; if (prefix) { - writer->bprefix_len = strlen((const char*)prefix); - writer->bprefix = (uint8_t*)malloc(writer->bprefix_len + 1); + writer->bprefix_len = strlen(prefix); + writer->bprefix = (char*)malloc(writer->bprefix_len + 1); memcpy(writer->bprefix, prefix, writer->bprefix_len + 1); } } @@ -1011,9 +1011,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/tests/env_test.c b/tests/env_test.c index 1ed7552e..1bd88edd 100644 --- a/tests/env_test.c +++ b/tests/env_test.c @@ -19,11 +19,8 @@ #include "serd/serd.h" #include -#include #include -#define USTR(s) ((const uint8_t*)(s)) - static SerdStatus count_prefixes(void* handle, const SerdNode* name, const SerdNode* uri) { @@ -37,11 +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)); @@ -55,32 +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/tests/serd_test.c b/tests/serd_test.c index ef50ebac..ab0a0896 100644 --- a/tests/serd_test.c +++ b/tests/serd_test.c @@ -27,8 +27,6 @@ #include #include -#define USTR(s) ((const uint8_t*)(s)) - #ifndef INFINITY # define INFINITY (DBL_MAX + DBL_MAX) #endif @@ -115,14 +113,12 @@ test_file_uri(const char* hostname, expected_path = path; } - SerdNode node = serd_node_new_file_uri( - USTR(path), USTR(hostname), 0, escape); - - uint8_t* out_hostname = NULL; - uint8_t* out_path = serd_file_uri_parse(node.buf, &out_hostname); - assert(!strcmp((const char*)node.buf, expected_uri)); + SerdNode node = serd_node_new_file_uri(path, hostname, 0, escape); + 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); @@ -200,8 +196,8 @@ test_read_string(void) // Test reading a string that ends exactly at the end of input (no newline) const SerdStatus st = serd_reader_read_string(reader, - USTR(" " - " .")); + " " + " ."); assert(!st); assert(rt->n_statements == 1); @@ -243,10 +239,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); } @@ -265,9 +261,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); } } @@ -283,7 +278,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 = (uint8_t*)serd_base64_decode( @@ -306,51 +301,51 @@ 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")); } static void test_uri_to_path(void) { - const uint8_t* uri = (const uint8_t*)"file:///home/user/foo.ttl"; - assert(!strcmp((const char*)serd_uri_to_path(uri), "/home/user/foo.ttl")); + const char* uri = "file:///home/user/foo.ttl"; + assert(!strcmp(serd_uri_to_path(uri), "/home/user/foo.ttl")); - uri = (const uint8_t*)"file://localhost/home/user/foo.ttl"; - assert(!strcmp((const char*)serd_uri_to_path(uri), "/home/user/foo.ttl")); + uri = "file://localhost/home/user/foo.ttl"; + assert(!strcmp(serd_uri_to_path(uri), "/home/user/foo.ttl")); - uri = (const uint8_t*)"file:illegal/file/uri"; + uri = "file:illegal/file/uri"; assert(!serd_uri_to_path(uri)); - uri = (const uint8_t*)"file:///c:/awful/system"; - assert(!strcmp((const char*)serd_uri_to_path(uri), "c:/awful/system")); + uri = "file:///c:/awful/system"; + assert(!strcmp(serd_uri_to_path(uri), "c:/awful/system")); - uri = (const uint8_t*)"file:///c:awful/system"; - assert(!strcmp((const char*)serd_uri_to_path(uri), "/c:awful/system")); + uri = "file:///c:awful/system"; + assert(!strcmp(serd_uri_to_path(uri), "/c:awful/system")); - uri = (const uint8_t*)"file:///0/1"; - assert(!strcmp((const char*)serd_uri_to_path(uri), "/0/1")); + uri = "file:///0/1"; + assert(!strcmp(serd_uri_to_path(uri), "/0/1")); - uri = (const uint8_t*)"C:\\Windows\\Sucks"; - assert(!strcmp((const char*)serd_uri_to_path(uri), "C:\\Windows\\Sucks")); + uri = "C:\\Windows\\Sucks"; + assert(!strcmp(serd_uri_to_path(uri), "C:\\Windows\\Sucks")); - uri = (const uint8_t*)"C|/Windows/Sucks"; - assert(!strcmp((const char*)serd_uri_to_path(uri), "C|/Windows/Sucks")); + uri = "C|/Windows/Sucks"; + assert(!strcmp(serd_uri_to_path(uri), "C|/Windows/Sucks")); } static void @@ -371,8 +366,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); } @@ -380,11 +375,11 @@ 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)); @@ -395,9 +390,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((const char*)node.buf, "hello\"")); + !strcmp(node.buf, "hello\"")); node = serd_node_from_string(SERD_URI, NULL); assert(serd_node_equals(&node, &SERD_NODE_NULL)); @@ -409,13 +404,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)); } static void @@ -425,14 +420,14 @@ test_uri_from_string(void) assert(nonsense.type == SERD_NOTHING); SerdURI base_uri; - SerdNode base = serd_node_new_uri_from_string(USTR("http://example.org/"), + SerdNode base = 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); @@ -442,30 +437,30 @@ test_uri_from_string(void) static void test_relative_uri(void) { - SerdURI base_uri; - SerdNode base = serd_node_new_uri_from_string(USTR("http://example.org/"), + SerdURI base_uri; + SerdNode base = 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")); + 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")); + 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); @@ -485,20 +480,20 @@ test_writer(const char* const path) 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, NULL, NULL, NULL }, @@ -517,8 +512,8 @@ test_writer(const char* const path) junk[i][0], junk[i][1], junk[i][2], junk[i][3], junk[i][4])); } - const SerdNode t = serd_node_from_string(SERD_URI, USTR("urn:Type")); - const SerdNode l = serd_node_from_string(SERD_LITERAL, USTR("en")); + const SerdNode 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 }, @@ -537,15 +532,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)); @@ -556,17 +551,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 .\n")); + assert(!strcmp(out, "@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( @@ -595,22 +590,22 @@ 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"); serd_reader_add_blank_prefix(reader, NULL); - 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 { -- cgit v1.2.1