From 83af030f55ec5360166f157f938b377e5e853638 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/byte_source.c | 8 +-- src/env.c | 12 ++-- src/n3.c | 2 +- src/node.c | 57 +++++++++-------- src/reader.c | 50 +++++++-------- src/reader.h | 2 +- src/serd_internal.h | 45 +++++++------ src/serdi.c | 26 ++++---- src/string.c | 38 +++++------ src/uri.c | 64 +++++++++---------- src/writer.c | 40 ++++++------ tests/serd_test.c | 177 +++++++++++++++++++++++++--------------------------- 14 files changed, 304 insertions(+), 308 deletions(-) diff --git a/NEWS b/NEWS index 98012285..ee6d5c97 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 ddfc39f9..db15cfc8 100644 --- a/serd/serd.h +++ b/serd/serd.h @@ -214,7 +214,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 */ @@ -224,8 +224,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; /** @@ -240,12 +240,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; /** @@ -300,7 +300,7 @@ serd_free(void* ptr); Return a string describing a status code. */ SERD_API -const uint8_t* +const char* serd_strerror(SerdStatus status); /** @@ -311,7 +311,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. @@ -336,7 +336,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); /** @} @@ -393,8 +393,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. @@ -405,22 +405,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`. @@ -468,7 +468,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`. @@ -478,7 +478,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); /** Make a deep copy of `node`. @@ -510,7 +510,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); @@ -526,10 +526,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. @@ -719,9 +719,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. @@ -825,8 +825,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. @@ -845,8 +845,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. @@ -858,10 +858,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. @@ -875,7 +875,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); /** @@ -902,9 +902,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. @@ -915,7 +915,7 @@ serd_reader_read_source(SerdReader* reader, SerdSource source, SerdStreamErrorFunc error, void* stream, - const uint8_t* name, + const char* name, size_t page_size); /** @@ -923,7 +923,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`. @@ -993,7 +993,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); /** @@ -1013,8 +1013,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/byte_source.c b/src/byte_source.c index 210e638e..55196b9a 100644 --- a/src/byte_source.c +++ b/src/byte_source.c @@ -39,7 +39,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 }; @@ -79,13 +79,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/env.c b/src/env.c index 1400dc2f..b2abed25 100644 --- a/src/env.c +++ b/src/env.c @@ -88,7 +88,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) { @@ -144,9 +144,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); @@ -182,7 +182,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; @@ -212,7 +212,7 @@ 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); return ret; diff --git a/src/n3.c b/src/n3.c index b9bc58cd..4223961d 100644 --- a/src/n3.c +++ b/src/n3.c @@ -859,7 +859,7 @@ read_BLANK_NODE_LABEL(SerdReader* reader, bool* ate_dot) eat_byte_safe(reader, '_'); eat_byte_check(reader, ':'); Ref ref = 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]) diff --git a/src/node.c b/src/node.c index 8946bb40..ab568208 100644 --- a/src/node.c +++ b/src/node.c @@ -31,7 +31,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; @@ -44,7 +44,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; @@ -64,7 +64,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; @@ -101,7 +101,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; @@ -118,7 +118,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) { @@ -133,7 +133,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; @@ -152,23 +152,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 }; @@ -188,11 +187,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 @@ -204,9 +203,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'; @@ -225,11 +224,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); @@ -260,7 +259,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 @@ -310,7 +309,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; @@ -355,7 +354,7 @@ serd_node_new_blob(const void* buf, size_t size, bool wrap_lines) { const size_t len = (size + 2) / 3 * 4 + (wrap_lines * ((size - 1) / 57)); 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 }; 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); @@ -375,7 +374,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 aa51670a..a0bf2ea2 100644 --- a/src/reader.c +++ b/src/reader.c @@ -80,7 +80,7 @@ Ref push_node_padded(SerdReader* reader, size_t maxlen, SerdType type, const char* str, size_t n_bytes) { - void* mem = serd_stack_push_aligned( + char* mem = (char*)serd_stack_push_aligned( &reader->stack, sizeof(SerdNode) + maxlen + 1, sizeof(SerdNode)); SerdNode* const node = (SerdNode*)mem; @@ -89,15 +89,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 = 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 @@ -111,7 +111,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; @@ -127,8 +127,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; } @@ -234,15 +234,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); } } @@ -256,15 +256,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; @@ -294,10 +294,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, @@ -313,7 +313,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( @@ -359,9 +359,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, @@ -373,7 +373,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( @@ -391,7 +391,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 7e4412ee..88603faa 100644 --- a/src/reader.h +++ b/src/reader.h @@ -75,7 +75,7 @@ push_byte(SerdReader* reader, Ref ref, const int c) assert(c != EOF); SERD_STACK_ASSERT_TOP(reader, ref); - uint8_t* const s = serd_stack_push(&reader->stack, 1); + char* const s = 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/serd_internal.h b/src/serd_internal.h index fb400eee..c87c6ae4 100644 --- a/src/serd_internal.h +++ b/src/serd_internal.h @@ -82,9 +82,9 @@ serd_bufalloc(size_t size) /* Byte source */ typedef struct { - const uint8_t* filename; - unsigned line; - unsigned col; + const char* filename; + unsigned line; + unsigned col; } Cursor; typedef struct { @@ -109,14 +109,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 @@ -175,7 +175,7 @@ serd_byte_source_advance(SerdByteSource* source) /** 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; @@ -187,7 +187,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; @@ -208,15 +208,15 @@ serd_stack_free(SerdStack* stack) stack->size = 0; } -static inline uint8_t* +static inline char* 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; } @@ -241,8 +241,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); @@ -255,7 +254,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); @@ -266,7 +265,7 @@ serd_stack_pop_aligned(SerdStack* stack, size_t n_bytes) typedef struct SerdByteSinkImpl { SerdSink sink; void* stream; - uint8_t* buf; + char* buf; size_t size; size_t block_size; } SerdByteSink; @@ -280,7 +279,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; } @@ -319,7 +318,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 @@ -380,13 +379,13 @@ 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] == '\\'); @@ -395,7 +394,7 @@ is_windows_path(const uint8_t* path) /* String utilities */ 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) @@ -463,7 +462,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) { @@ -491,8 +490,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 == '/') { @@ -592,7 +591,7 @@ struct SerdReaderImpl { unsigned next_id; SerdStatus status; uint8_t* buf; - uint8_t* bprefix; + char* bprefix; size_t bprefix_len; bool strict; ///< True iff strict parsing bool seen_genid; diff --git a/src/serdi.c b/src/serdi.c index 03de46fd..963a1b49 100644 --- a/src/serdi.c +++ b/src/serdi.c @@ -137,14 +137,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') { @@ -164,7 +164,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; @@ -184,17 +184,17 @@ main(int argc, char** argv) if (++a == argc) { return missing_arg(argv[0], 'p'); } - add_prefix = (const uint8_t*)argv[a]; + add_prefix = (const char*)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 = (const char*)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 = (const char*)argv[a]; } else { SERDI_ERRORF("invalid option -- '%s'\n", argv[a] + 1); return print_usage(argv[0], true); @@ -211,18 +211,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; } @@ -237,7 +237,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/string.c b/src/string.c index 075af52d..b564a874 100644 --- a/src/string.c +++ b/src/string.c @@ -24,25 +24,25 @@ 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"; } - 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': @@ -54,7 +54,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) { @@ -70,7 +70,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; @@ -81,7 +81,7 @@ serd_strlen(const uint8_t* str, SerdNodeFlags* flags) return i; } - return strlen((const char*)str); + return strlen(str); } static inline double @@ -175,16 +175,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* 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/uri.c b/src/uri.c index 1cce3a65..b17f0e42 100644 --- a/src/uri.c +++ b/src/uri.c @@ -19,17 +19,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); @@ -42,23 +42,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)); } } @@ -69,14 +69,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 { @@ -90,14 +90,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; (c = *++utf8) != '\0';) { + for (char c; (c = *++utf8) != '\0';) { if (!is_uri_scheme_char(c)) { return false; } else if (c == ':') { @@ -109,11 +109,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 ] @@ -121,7 +121,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; @@ -148,7 +148,7 @@ maybe_authority: if (*ptr == '/' && *(ptr + 1) == '/') { ptr += 2; out->authority.buf = ptr; - for (uint8_t c; (c = *ptr) != '\0'; ++ptr) { + for (char c; (c = *ptr) != '\0'; ++ptr) { switch (c) { case '/': goto path; case '?': goto query; @@ -171,7 +171,7 @@ path: } out->path.buf = ptr; out->path.len = 0; - for (uint8_t c; (c = *ptr) != '\0'; ++ptr) { + for (char c; (c = *ptr) != '\0'; ++ptr) { switch (c) { case '?': goto query; case '#': goto fragment; @@ -187,7 +187,7 @@ path: query: if (*ptr == '?') { out->query.buf = ++ptr; - for (uint8_t c; (c = *ptr) != '\0'; ++ptr) { + for (char c; (c = *ptr) != '\0'; ++ptr) { if (c == '#') { goto fragment; } @@ -217,11 +217,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) { @@ -282,13 +282,13 @@ remove_dot_segments(const uint8_t* path, size_t len, size_t* up) static void merge(SerdChunk* base, SerdChunk* path) { - size_t up; - const uint8_t* begin = remove_dot_segments(path->buf, path->len, &up); - const uint8_t* end = path->buf + path->len; + size_t up; + 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/writer.c b/src/writer.c index 1b6d0829..3f198a93 100644 --- a/src/writer.c +++ b/src/writer.c @@ -93,7 +93,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 @@ 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; @@ -195,7 +195,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 '\\': @@ -207,7 +207,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;) { @@ -226,7 +226,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 @@ -237,7 +237,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 @@ -258,7 +258,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) { @@ -284,7 +284,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;) { @@ -338,7 +338,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) {} @@ -352,7 +353,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 @@ -462,7 +463,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) { @@ -595,9 +596,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); @@ -878,15 +878,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); } } @@ -984,9 +984,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/serd_test.c b/tests/serd_test.c index c6b5de95..2462f1c0 100644 --- a/tests/serd_test.c +++ b/tests/serd_test.c @@ -26,8 +26,6 @@ #include "serd/serd.h" -#define USTR(s) ((const uint8_t*)(s)) - #ifndef INFINITY # define INFINITY (DBL_MAX + DBL_MAX) #endif @@ -97,14 +95,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); @@ -210,10 +206,10 @@ test_double_to_node(void) for (unsigned 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, (const char*)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); } @@ -232,9 +228,8 @@ test_integer_to_node(void) for (unsigned 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); } } @@ -250,7 +245,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; uint8_t* out = (uint8_t*)serd_base64_decode( @@ -273,19 +268,19 @@ test_strlen(void) const uint8_t str[] = { '"', '5', 0xE2, 0x82, 0xAC, '"', '\n', 0 }; SerdNodeFlags flags; - 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 = NULL; - assert(!strcmp((const char*)(msg = serd_strerror(SERD_SUCCESS)), "Success")); + const char* msg = NULL; + assert(!strcmp((msg = serd_strerror(SERD_SUCCESS)), "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); } @@ -293,29 +288,29 @@ test_strerror(void) 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 @@ -336,8 +331,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); } @@ -345,11 +340,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)); @@ -360,9 +355,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)); @@ -374,13 +369,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 @@ -390,14 +385,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); @@ -407,30 +402,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); @@ -442,11 +437,11 @@ test_relative_uri(void) 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)); @@ -459,28 +454,28 @@ 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)); 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)); @@ -498,20 +493,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 }, @@ -530,8 +525,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 }, @@ -550,15 +545,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)); @@ -569,13 +564,13 @@ 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); serd_env_free(env); fclose(fd); @@ -591,22 +586,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.")); serd_reader_free(reader); } -- cgit v1.2.1