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. --- 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 ++++++++++++++++----------------- 11 files changed, 172 insertions(+), 172 deletions(-) (limited to 'src') 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; } -- cgit v1.2.1