From 83af030f55ec5360166f157f938b377e5e853638 Mon Sep 17 00:00:00 2001
From: David Robillard <d@drobilla.net>
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 <stdlib.h>
#include <string.h>
-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