aboutsummaryrefslogtreecommitdiffstats
path: root/src/reader.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/reader.c')
-rw-r--r--src/reader.c902
1 files changed, 450 insertions, 452 deletions
diff --git a/src/reader.c b/src/reader.c
index 93f6dd48..9aa0d12a 100644
--- a/src/reader.c
+++ b/src/reader.c
@@ -28,8 +28,8 @@
#define TRY_THROW(exp) if (!(exp)) goto except;
#define TRY_RET(exp) if (!(exp)) return 0;
-#define STACK_CHUNK_SIZE 4096
-#define STACK_INITIAL_TOP 8
+#define READ_BUF_LEN 4096
+#define STACK_CHUNK_SIZE 4096
#ifndef NDEBUG
#define STACK_DEBUG 1
#endif
@@ -50,8 +50,6 @@ typedef uint32_t uchar;
typedef size_t Ref;
-static const int32_t READ_BUF_LEN = 4096;
-static const int32_t MAX_READAHEAD = 8;
typedef struct {
SerdNodeType type;
@@ -63,26 +61,26 @@ typedef struct {
static const Node SERD_NODE_NULL = {0,0,0,0};
struct SerdReaderImpl {
- void* handle;
- SerdBaseHandler base_handler;
- SerdPrefixHandler prefix_handler;
- SerdStatementHandler statement_handler;
- Node rdf_type;
- Node rdf_first;
- Node rdf_rest;
- Node rdf_nil;
- FILE* fd;
- Stack stack;
- Cursor cur;
- uint8_t* buf;
- unsigned next_id;
- int err;
- uint8_t* read_buf;
- int32_t read_head; ///< Offset into read_buf
- bool eof;
+ void* handle;
+ SerdBaseSink base_sink;
+ SerdPrefixSink prefix_sink;
+ SerdStatementSink statement_sink;
+ Node rdf_type;
+ Node rdf_first;
+ Node rdf_rest;
+ Node rdf_nil;
+ FILE* fd;
+ Stack stack;
+ Cursor cur;
+ uint8_t* buf;
+ unsigned next_id;
+ int err;
+ uint8_t* read_buf;
+ int32_t read_head; ///< Offset into read_buf
+ bool eof;
#ifdef STACK_DEBUG
- Ref* alloc_stack; ///< Stack of push offsets
- size_t n_allocs; ///< Number of stack pushes
+ Ref* alloc_stack; ///< Stack of push offsets
+ size_t n_allocs; ///< Number of stack pushes
#endif
};
@@ -93,14 +91,14 @@ typedef enum {
} SerdStatus;
static inline int
-error(SerdReader parser, const char* fmt, ...)
+error(SerdReader reader, const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
fprintf(stderr, "error: %s:%u:%u: ",
- parser->cur.filename, parser->cur.line, parser->cur.col);
+ reader->cur.filename, reader->cur.line, reader->cur.col);
vfprintf(stderr, fmt, args);
- parser->err = 1;
+ reader->err = 1;
return 0;
}
@@ -112,33 +110,33 @@ make_node(SerdNodeType type, Ref value, Ref datatype, Ref lang)
}
static inline bool
-page(SerdReader parser)
+page(SerdReader reader)
{
- parser->read_head = 0;
- const int32_t n_read = fread(parser->read_buf, 1, READ_BUF_LEN, parser->fd);
+ reader->read_head = 0;
+ const int32_t n_read = fread(reader->read_buf, 1, READ_BUF_LEN, reader->fd);
if (n_read == 0) {
- parser->read_buf[0] = '\0';
- parser->eof = true;
+ reader->read_buf[0] = '\0';
+ reader->eof = true;
return false;
} else if (n_read < READ_BUF_LEN) {
- parser->read_buf[n_read] = '\0';
+ reader->read_buf[n_read] = '\0';
}
return true;
}
static inline bool
-readahead(SerdReader parser, uint8_t* pre, int n)
+readahead(SerdReader reader, uint8_t* pre, int n)
{
- uint8_t* ptr = parser->read_buf + parser->read_head;
+ uint8_t* ptr = reader->read_buf + reader->read_head;
for (int i = 0; i < n; ++i) {
- if (parser->read_head + i >= READ_BUF_LEN) {
- if (!page(parser)) {
+ if (reader->read_head + i >= READ_BUF_LEN) {
+ if (!page(reader)) {
return false;
}
- ptr = parser->read_buf;
- parser->read_head = -i;
- memcpy(parser->read_buf + parser->read_head, pre, i);
- assert(parser->read_buf[parser->read_head] == pre[0]);
+ ptr = reader->read_buf;
+ reader->read_head = -i;
+ memcpy(reader->read_buf + reader->read_head, pre, i);
+ assert(reader->read_buf[reader->read_head] == pre[0]);
}
if ((pre[i] = *ptr++) == '\0') {
return false;
@@ -148,39 +146,39 @@ readahead(SerdReader parser, uint8_t* pre, int n)
}
static inline uint8_t
-peek_byte(SerdReader parser)
+peek_byte(SerdReader reader)
{
- return parser->read_buf[parser->read_head];
+ return reader->read_buf[reader->read_head];
}
static inline uint8_t
-eat_byte(SerdReader parser, const uint8_t byte)
+eat_byte(SerdReader reader, const uint8_t byte)
{
- const uint8_t c = peek_byte(parser);
- ++parser->read_head;
+ const uint8_t c = peek_byte(reader);
+ ++reader->read_head;
switch (c) {
- case '\n': ++parser->cur.line; parser->cur.col = 0; break;
- default: ++parser->cur.col;
+ case '\n': ++reader->cur.line; reader->cur.col = 0; break;
+ default: ++reader->cur.col;
}
if (c != byte) {
- return error(parser, "expected `%c', not `%c'\n", byte, c);
+ return error(reader, "expected `%c', not `%c'\n", byte, c);
}
- if (parser->read_head == READ_BUF_LEN) {
- TRY_RET(page(parser));
+ if (reader->read_head == READ_BUF_LEN) {
+ TRY_RET(page(reader));
}
- assert(parser->read_head < READ_BUF_LEN);
- if (parser->read_buf[parser->read_head] == '\0') {
- parser->eof = true;
+ assert(reader->read_head < READ_BUF_LEN);
+ if (reader->read_buf[reader->read_head] == '\0') {
+ reader->eof = true;
}
return c;
}
static inline void
-eat_string(SerdReader parser, const char* str, unsigned n)
+eat_string(SerdReader reader, const char* str, unsigned n)
{
for (unsigned i = 0; i < n; ++i) {
- eat_byte(parser, ((const uint8_t*)str)[i]);
+ eat_byte(reader, ((const uint8_t*)str)[i]);
}
}
@@ -192,22 +190,22 @@ in_range(const uchar c, const uchar min, const uchar max)
#ifdef STACK_DEBUG
static inline bool
-stack_is_top_string(SerdReader parser, Ref ref)
+stack_is_top_string(SerdReader reader, Ref ref)
{
- return ref == parser->alloc_stack[parser->n_allocs - 1];
+ return ref == reader->alloc_stack[reader->n_allocs - 1];
}
#endif
static inline uint8_t*
-stack_push(SerdReader parser, size_t n_bytes)
+stack_push(SerdReader reader, size_t n_bytes)
{
- const size_t new_size = parser->stack.size + n_bytes;
- if (parser->stack.buf_size < new_size) {
- parser->stack.buf_size = ((new_size / STACK_CHUNK_SIZE) + 1) * STACK_CHUNK_SIZE;
- parser->stack.buf = realloc(parser->stack.buf, parser->stack.buf_size);
+ const size_t new_size = reader->stack.size + n_bytes;
+ if (reader->stack.buf_size < new_size) {
+ reader->stack.buf_size = ((new_size / STACK_CHUNK_SIZE) + 1) * STACK_CHUNK_SIZE;
+ reader->stack.buf = realloc(reader->stack.buf, reader->stack.buf_size);
}
- uint8_t* const ret = (parser->stack.buf + parser->stack.size);
- parser->stack.size = new_size;
+ uint8_t* const ret = (reader->stack.buf + reader->stack.size);
+ reader->stack.size = new_size;
return ret;
}
@@ -219,40 +217,40 @@ pad_size(intptr_t size)
// Make a new string from a non-UTF-8 C string (internal use only)
static Ref
-push_string(SerdReader parser, const char* c_str, size_t n_bytes)
+push_string(SerdReader reader, const char* c_str, size_t n_bytes)
{
// Align strings to 64-bits (assuming malloc/realloc are aligned to 64-bits)
- const size_t stack_size = pad_size((intptr_t)parser->stack.size);
- const size_t pad = stack_size - parser->stack.size;
+ const size_t stack_size = pad_size((intptr_t)reader->stack.size);
+ const size_t pad = stack_size - reader->stack.size;
SerdString* const str = (SerdString*)(
- stack_push(parser, pad + sizeof(SerdString) + n_bytes) + pad);
+ stack_push(reader, pad + sizeof(SerdString) + n_bytes) + pad);
str->n_bytes = n_bytes;
str->n_chars = n_bytes - 1;
memcpy(str->buf, c_str, n_bytes);
#ifdef STACK_DEBUG
- parser->alloc_stack = realloc(parser->alloc_stack, sizeof(uint8_t*) * (++parser->n_allocs));
- parser->alloc_stack[parser->n_allocs - 1] = ((uint8_t*)str - parser->stack.buf);
+ reader->alloc_stack = realloc(reader->alloc_stack, sizeof(uint8_t*) * (++reader->n_allocs));
+ reader->alloc_stack[reader->n_allocs - 1] = ((uint8_t*)str - reader->stack.buf);
#endif
- return (uint8_t*)str - parser->stack.buf;
+ return (uint8_t*)str - reader->stack.buf;
}
static inline SerdString*
-deref(SerdReader parser, const Ref ref)
+deref(SerdReader reader, const Ref ref)
{
if (ref) {
- return (SerdString*)(parser->stack.buf + ref);
+ return (SerdString*)(reader->stack.buf + ref);
}
return NULL;
}
static inline void
-push_byte(SerdReader parser, Ref ref, const uint8_t c)
+push_byte(SerdReader reader, Ref ref, const uint8_t c)
{
#ifdef STACK_DEBUG
- assert(stack_is_top_string(parser, ref));
+ assert(stack_is_top_string(reader, ref));
#endif
- stack_push(parser, 1);
- SerdString* const str = deref(parser, ref);
+ stack_push(reader, 1);
+ SerdString* const str = deref(reader, ref);
++str->n_bytes;
if ((c & 0xC0) != 0x80) {
// Does not start with `10', start of a new character
@@ -264,60 +262,60 @@ push_byte(SerdReader parser, Ref ref, const uint8_t c)
}
static void
-pop_string(SerdReader parser, Ref ref)
+pop_string(SerdReader reader, Ref ref)
{
if (ref) {
- if (ref == parser->rdf_nil.value
- || ref == parser->rdf_first.value
- || ref == parser->rdf_rest.value) {
+ if (ref == reader->rdf_nil.value
+ || ref == reader->rdf_first.value
+ || ref == reader->rdf_rest.value) {
return;
}
#ifdef STACK_DEBUG
- if (!stack_is_top_string(parser, ref)) {
- fprintf(stderr, "attempt to pop non-top string %s\n", deref(parser, ref)->buf);
+ if (!stack_is_top_string(reader, ref)) {
+ fprintf(stderr, "attempt to pop non-top string %s\n", deref(reader, ref)->buf);
fprintf(stderr, "top: %s\n",
- deref(parser, parser->alloc_stack[parser->n_allocs - 1])->buf);
+ deref(reader, reader->alloc_stack[reader->n_allocs - 1])->buf);
}
- assert(stack_is_top_string(parser, ref));
- --parser->n_allocs;
+ assert(stack_is_top_string(reader, ref));
+ --reader->n_allocs;
#endif
- parser->stack.size -= deref(parser, ref)->n_bytes;
+ reader->stack.size -= deref(reader, ref)->n_bytes;
}
}
static inline void
-emit_statement(SerdReader parser,
+emit_statement(SerdReader reader,
const Node* g, const Node* s, const Node* p, const Node* o)
{
- parser->statement_handler(parser->handle,
- g ? deref(parser, g->value) : NULL,
- deref(parser, s->value), s->type,
- deref(parser, p->value), p->type,
- deref(parser, o->value), o->type,
- deref(parser, o->datatype), deref(parser, o->lang));
+ reader->statement_sink(reader->handle,
+ g ? deref(reader, g->value) : NULL,
+ deref(reader, s->value), s->type,
+ deref(reader, p->value), p->type,
+ deref(reader, o->value), o->type,
+ deref(reader, o->datatype), deref(reader, o->lang));
}
-static bool read_collection(SerdReader parser, Node* dest);
-static bool read_predicateObjectList(SerdReader parser, const Node* subject);
+static bool read_collection(SerdReader reader, Node* dest);
+static bool read_predicateObjectList(SerdReader reader, const Node* subject);
// [40] hex ::= [#x30-#x39] | [#x41-#x46]
static inline uint8_t
-read_hex(SerdReader parser)
+read_hex(SerdReader reader)
{
- const uint8_t c = peek_byte(parser);
+ const uint8_t c = peek_byte(reader);
if (in_range(c, 0x30, 0x39) || in_range(c, 0x41, 0x46)) {
- return eat_byte(parser, c);
+ return eat_byte(reader, c);
} else {
- return error(parser, "illegal hexadecimal digit `%c'\n", c);
+ return error(reader, "illegal hexadecimal digit `%c'\n", c);
}
}
static inline bool
-read_hex_escape(SerdReader parser, unsigned length, Ref dest)
+read_hex_escape(SerdReader reader, unsigned length, Ref dest)
{
uint8_t buf[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
for (unsigned i = 0; i < length; ++i) {
- buf[i] = read_hex(parser);
+ buf[i] = read_hex(reader);
}
uint32_t c;
@@ -368,71 +366,71 @@ read_hex_escape(SerdReader parser, unsigned length, Ref dest)
}
for (unsigned i = 0; i < size; ++i) {
- push_byte(parser, dest, buf[i]);
+ push_byte(reader, dest, buf[i]);
}
return true;
}
static inline bool
-read_character_escape(SerdReader parser, Ref dest)
+read_character_escape(SerdReader reader, Ref dest)
{
- switch (peek_byte(parser)) {
+ switch (peek_byte(reader)) {
case '\\':
- push_byte(parser, dest, eat_byte(parser, '\\'));
+ push_byte(reader, dest, eat_byte(reader, '\\'));
return true;
case 'u':
- eat_byte(parser, 'u');
- return read_hex_escape(parser, 4, dest);
+ eat_byte(reader, 'u');
+ return read_hex_escape(reader, 4, dest);
case 'U':
- eat_byte(parser, 'U');
- return read_hex_escape(parser, 8, dest);
+ eat_byte(reader, 'U');
+ return read_hex_escape(reader, 8, dest);
default:
return false;
}
}
static inline bool
-read_echaracter_escape(SerdReader parser, Ref dest)
+read_echaracter_escape(SerdReader reader, Ref dest)
{
- switch (peek_byte(parser)) {
+ switch (peek_byte(reader)) {
case 't':
- eat_byte(parser, 't');
- push_byte(parser, dest, '\t');
+ eat_byte(reader, 't');
+ push_byte(reader, dest, '\t');
return true;
case 'n':
- eat_byte(parser, 'n');
- push_byte(parser, dest, '\n');
+ eat_byte(reader, 'n');
+ push_byte(reader, dest, '\n');
return true;
case 'r':
- eat_byte(parser, 'r');
- push_byte(parser, dest, '\r');
+ eat_byte(reader, 'r');
+ push_byte(reader, dest, '\r');
return true;
default:
- return read_character_escape(parser, dest);
+ return read_character_escape(reader, dest);
}
}
static inline bool
-read_scharacter_escape(SerdReader parser, Ref dest)
+read_scharacter_escape(SerdReader reader, Ref dest)
{
- switch (peek_byte(parser)) {
+ switch (peek_byte(reader)) {
case '"':
- push_byte(parser, dest, eat_byte(parser, '"'));
+ push_byte(reader, dest, eat_byte(reader, '"'));
return true;
default:
- return read_echaracter_escape(parser, dest);
+ return read_echaracter_escape(reader, dest);
}
}
static inline bool
-read_ucharacter_escape(SerdReader parser, Ref dest)
+read_ucharacter_escape(SerdReader reader, Ref dest)
{
- switch (peek_byte(parser)) {
+ switch (peek_byte(reader)) {
case '>':
- push_byte(parser, dest, eat_byte(parser, '>'));
+ push_byte(reader, dest, eat_byte(reader, '>'));
return true;
default:
- return read_echaracter_escape(parser, dest);
+ return read_echaracter_escape(reader, dest);
}
}
@@ -441,27 +439,27 @@ read_ucharacter_escape(SerdReader parser, Ref dest)
// | '\\'
// | [#x20-#x5B] | [#x5D-#x10FFFF]
static inline SerdStatus
-read_character(SerdReader parser, Ref dest)
+read_character(SerdReader reader, Ref dest)
{
- const uint8_t c = peek_byte(parser);
+ const uint8_t c = peek_byte(reader);
switch (c) {
case '\0':
- error(parser, "unexpected end of file\n", peek_byte(parser));
+ error(reader, "unexpected end of file\n", peek_byte(reader));
return SERD_ERROR;
case '\\': // 0x5C
- eat_byte(parser, '\\');
- if (read_character_escape(parser, dest)) {
+ eat_byte(reader, '\\');
+ if (read_character_escape(reader, dest)) {
return SERD_SUCCESS;
} else {
- error(parser, "invalid escape `\\%c'\n", peek_byte(parser));
+ error(reader, "invalid escape `\\%c'\n", peek_byte(reader));
return SERD_ERROR;
}
default:
if (c < 0x20) { // ASCII control character
- error(parser, "unexpected control character\n");
+ error(reader, "unexpected control character\n");
return SERD_ERROR;
} else if (c <= 0x7E) { // Printable ASCII
- push_byte(parser, dest, eat_byte(parser, c));
+ push_byte(reader, dest, eat_byte(reader, c));
return SERD_SUCCESS;
} else { // Wide UTF-8 character
unsigned size = 1;
@@ -476,11 +474,11 @@ read_character(SerdReader parser, Ref dest)
} else if ((c & 0xFE) == 0xFC) { // Starts with `1111110'
size = 6;
} else {
- error(parser, "invalid character\n");
+ error(reader, "invalid character\n");
return SERD_ERROR;
}
for (unsigned i = 0; i < size; ++i) {
- push_byte(parser, dest, eat_byte(parser, peek_byte(parser)));
+ push_byte(reader, dest, eat_byte(reader, peek_byte(reader)));
}
return SERD_SUCCESS;
}
@@ -489,121 +487,121 @@ read_character(SerdReader parser, Ref dest)
// [39] echaracter ::= character | '\t' | '\n' | '\r'
static inline SerdStatus
-read_echaracter(SerdReader parser, Ref dest)
+read_echaracter(SerdReader reader, Ref dest)
{
- uint8_t c = peek_byte(parser);
+ uint8_t c = peek_byte(reader);
switch (c) {
case '\\':
- eat_byte(parser, '\\');
- if (read_echaracter_escape(parser, peek_byte(parser))) {
+ eat_byte(reader, '\\');
+ if (read_echaracter_escape(reader, peek_byte(reader))) {
return SERD_SUCCESS;
} else {
- error(parser, "illegal escape `\\%c'\n", peek_byte(parser));
+ error(reader, "illegal escape `\\%c'\n", peek_byte(reader));
return SERD_ERROR;
}
default:
- return read_character(parser, dest);
+ return read_character(reader, dest);
}
}
// [43] lcharacter ::= echaracter | '\"' | #x9 | #xA | #xD
static inline SerdStatus
-read_lcharacter(SerdReader parser, Ref dest)
+read_lcharacter(SerdReader reader, Ref dest)
{
- const uint8_t c = peek_byte(parser);
+ const uint8_t c = peek_byte(reader);
uint8_t pre[3];
switch (c) {
case '"':
- readahead(parser, pre, 3);
+ readahead(reader, pre, 3);
if (pre[1] == '\"' && pre[2] == '\"') {
- eat_byte(parser, '\"');
- eat_byte(parser, '\"');
- eat_byte(parser, '\"');
+ eat_byte(reader, '\"');
+ eat_byte(reader, '\"');
+ eat_byte(reader, '\"');
return SERD_FAILURE;
} else {
- push_byte(parser, dest, eat_byte(parser, '"'));
+ push_byte(reader, dest, eat_byte(reader, '"'));
return SERD_SUCCESS;
}
case '\\':
- eat_byte(parser, '\\');
- if (read_scharacter_escape(parser, dest)) {
+ eat_byte(reader, '\\');
+ if (read_scharacter_escape(reader, dest)) {
return SERD_SUCCESS;
} else {
- error(parser, "illegal escape `\\%c'\n", peek_byte(parser));
+ error(reader, "illegal escape `\\%c'\n", peek_byte(reader));
return SERD_ERROR;
}
case 0x9: case 0xA: case 0xD:
- push_byte(parser, dest, eat_byte(parser, c));
+ push_byte(reader, dest, eat_byte(reader, c));
return SERD_SUCCESS;
default:
- return read_echaracter(parser, dest);
+ return read_echaracter(reader, dest);
}
}
// [42] scharacter ::= ( echaracter - #x22 ) | '\"'
static inline SerdStatus
-read_scharacter(SerdReader parser, Ref dest)
+read_scharacter(SerdReader reader, Ref dest)
{
- uint8_t c = peek_byte(parser);
+ uint8_t c = peek_byte(reader);
switch (c) {
case '\\':
- eat_byte(parser, '\\');
- if (read_scharacter_escape(parser, dest)) {
+ eat_byte(reader, '\\');
+ if (read_scharacter_escape(reader, dest)) {
return SERD_SUCCESS;
} else {
- error(parser, "illegal escape `\\%c'\n", peek_byte(parser));
+ error(reader, "illegal escape `\\%c'\n", peek_byte(reader));
return SERD_ERROR;
}
case '\"':
return SERD_FAILURE;
default:
- return read_character(parser, dest);
+ return read_character(reader, dest);
}
}
// Spec: [41] ucharacter ::= ( character - #x3E ) | '\>'
// Actual: [41] ucharacter ::= ( echaracter - #x3E ) | '\>'
static inline SerdStatus
-read_ucharacter(SerdReader parser, Ref dest)
+read_ucharacter(SerdReader reader, Ref dest)
{
- const uint8_t c = peek_byte(parser);
+ const uint8_t c = peek_byte(reader);
switch (c) {
case '\\':
- eat_byte(parser, '\\');
- if (read_ucharacter_escape(parser, dest)) {
+ eat_byte(reader, '\\');
+ if (read_ucharacter_escape(reader, dest)) {
return SERD_SUCCESS;
} else {
- return error(parser, "illegal escape `\\%c'\n", peek_byte(parser));
+ return error(reader, "illegal escape `\\%c'\n", peek_byte(reader));
}
case '>':
return SERD_FAILURE;
default:
- return read_character(parser, dest);
+ return read_character(reader, dest);
}
}
// [10] comment ::= '#' ( [^#xA #xD] )*
static void
-read_comment(SerdReader parser)
+read_comment(SerdReader reader)
{
- eat_byte(parser, '#');
+ eat_byte(reader, '#');
uint8_t c;
- while (((c = peek_byte(parser)) != 0xA) && (c != 0xD)) {
- eat_byte(parser, c);
+ while (((c = peek_byte(reader)) != 0xA) && (c != 0xD)) {
+ eat_byte(reader, c);
}
}
// [24] ws ::= #x9 | #xA | #xD | #x20 | comment
static inline bool
-read_ws(SerdReader parser)
+read_ws(SerdReader reader)
{
- const uint8_t c = peek_byte(parser);
+ const uint8_t c = peek_byte(reader);
switch (c) {
case 0x9: case 0xA: case 0xD: case 0x20:
- eat_byte(parser, c);
+ eat_byte(reader, c);
return true;
case '#':
- read_comment(parser);
+ read_comment(reader);
return true;
default:
return false;
@@ -611,79 +609,79 @@ read_ws(SerdReader parser)
}
static inline void
-read_ws_star(SerdReader parser)
+read_ws_star(SerdReader reader)
{
- while (read_ws(parser)) {}
+ while (read_ws(reader)) {}
}
static inline bool
-read_ws_plus(SerdReader parser)
+read_ws_plus(SerdReader reader)
{
- TRY_RET(read_ws(parser));
- read_ws_star(parser);
+ TRY_RET(read_ws(reader));
+ read_ws_star(reader);
return true;
}
// [37] longSerdString ::= #x22 #x22 #x22 lcharacter* #x22 #x22 #x22
static Ref
-read_longString(SerdReader parser)
+read_longString(SerdReader reader)
{
- eat_string(parser, "\"\"\"", 3);
- Ref str = push_string(parser, "", 1);
+ eat_string(reader, "\"\"\"", 3);
+ Ref str = push_string(reader, "", 1);
SerdStatus st;
- while (!(st = read_lcharacter(parser, str))) {}
+ while (!(st = read_lcharacter(reader, str))) {}
if (st != SERD_ERROR) {
return str;
}
- pop_string(parser, str);
+ pop_string(reader, str);
return 0;
}
// [36] string ::= #x22 scharacter* #x22
static Ref
-read_string(SerdReader parser)
+read_string(SerdReader reader)
{
- eat_byte(parser, '\"');
- Ref str = push_string(parser, "", 1);
+ eat_byte(reader, '\"');
+ Ref str = push_string(reader, "", 1);
SerdStatus st;
- while (!(st = read_scharacter(parser, str))) {}
+ while (!(st = read_scharacter(reader, str))) {}
if (st != SERD_ERROR) {
- eat_byte(parser, '\"');
+ eat_byte(reader, '\"');
return str;
}
- pop_string(parser, str);
+ pop_string(reader, str);
return 0;
}
// [35] quotedString ::= string | longSerdString
static Ref
-read_quotedString(SerdReader parser)
+read_quotedString(SerdReader reader)
{
uint8_t pre[3];
- readahead(parser, pre, 3);
+ readahead(reader, pre, 3);
assert(pre[0] == '\"');
switch (pre[1]) {
case '\"':
if (pre[2] == '\"')
- return read_longString(parser);
+ return read_longString(reader);
else
- return read_string(parser);
+ return read_string(reader);
default:
- return read_string(parser);
+ return read_string(reader);
}
}
// [34] relativeURI ::= ucharacter*
static inline Ref
-read_relativeURI(SerdReader parser)
+read_relativeURI(SerdReader reader)
{
- Ref str = push_string(parser, "", 1);
+ Ref str = push_string(reader, "", 1);
SerdStatus st;
- while (!(st = read_ucharacter(parser, str))) {}
+ while (!(st = read_ucharacter(reader, str))) {}
if (st != SERD_ERROR) {
return str;
}
- pop_string(parser, str);
+ pop_string(reader, str);
return 0;
}
@@ -692,14 +690,14 @@ read_relativeURI(SerdReader parser)
// | [#x037F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF]
// | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
static inline uchar
-read_nameStartChar(SerdReader parser, bool required)
+read_nameStartChar(SerdReader reader, bool required)
{
- const uint8_t c = peek_byte(parser);
+ const uint8_t c = peek_byte(reader);
if (in_range(c, 'A', 'Z') || (c == '_') || in_range(c, 'a', 'z')) {
- return eat_byte(parser, c);
+ return eat_byte(reader, c);
} else {
if (required) {
- error(parser, "illegal character `%c'\n", c);
+ error(reader, "illegal character `%c'\n", c);
}
return 0;
}
@@ -707,19 +705,19 @@ read_nameStartChar(SerdReader parser, bool required)
// [31] nameChar ::= nameStartChar | '-' | [0-9] | #x00B7 | [#x0300-#x036F] | [#x203F-#x2040]
static inline uchar
-read_nameChar(SerdReader parser)
+read_nameChar(SerdReader reader)
{
- uchar c = read_nameStartChar(parser, false);
+ uchar c = read_nameStartChar(reader, false);
if (c)
return c;
- switch ((c = peek_byte(parser))) {
+ switch ((c = peek_byte(reader))) {
case '-': case 0xB7: case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
- return eat_byte(parser, c);
+ return eat_byte(reader, c);
default:
if (in_range(c, 0x300, 0x036F) || in_range(c, 0x203F, 0x2040)) {
- return eat_byte(parser, c);
+ return eat_byte(reader, c);
}
}
return 0;
@@ -727,58 +725,58 @@ read_nameChar(SerdReader parser)
// [33] prefixName ::= ( nameStartChar - '_' ) nameChar*
static Ref
-read_prefixName(SerdReader parser)
+read_prefixName(SerdReader reader)
{
- uint8_t c = peek_byte(parser);
+ uint8_t c = peek_byte(reader);
if (c == '_') {
- error(parser, "unexpected `_'\n");
+ error(reader, "unexpected `_'\n");
return 0;
}
- TRY_RET(c = read_nameStartChar(parser, false));
- Ref str = push_string(parser, "", 1);
- push_byte(parser, str, c);
- while ((c = read_nameChar(parser)) != 0) {
- push_byte(parser, str, c);
+ TRY_RET(c = read_nameStartChar(reader, false));
+ Ref str = push_string(reader, "", 1);
+ push_byte(reader, str, c);
+ while ((c = read_nameChar(reader)) != 0) {
+ push_byte(reader, str, c);
}
return str;
}
// [32] name ::= nameStartChar nameChar*
static Ref
-read_name(SerdReader parser, Ref dest, bool required)
+read_name(SerdReader reader, Ref dest, bool required)
{
- uchar c = read_nameStartChar(parser, required);
+ uchar c = read_nameStartChar(reader, required);
if (!c) {
if (required) {
- error(parser, "illegal character at start of name\n");
+ error(reader, "illegal character at start of name\n");
}
return 0;
}
do {
- push_byte(parser, dest, c);
- } while ((c = read_nameChar(parser)) != 0);
+ push_byte(reader, dest, c);
+ } while ((c = read_nameChar(reader)) != 0);
return dest;
}
// [29] language ::= [a-z]+ ('-' [a-z0-9]+ )*
static Ref
-read_language(SerdReader parser)
+read_language(SerdReader reader)
{
- const uint8_t start = peek_byte(parser);
+ const uint8_t start = peek_byte(reader);
if (!in_range(start, 'a', 'z')) {
- error(parser, "unexpected `%c'\n", start);
+ error(reader, "unexpected `%c'\n", start);
return 0;
}
- Ref str = push_string(parser, "", 1);
- push_byte(parser, str, eat_byte(parser, start));
+ Ref str = push_string(reader, "", 1);
+ push_byte(reader, str, eat_byte(reader, start));
uint8_t c;
- while ((c = peek_byte(parser)) && in_range(c, 'a', 'z')) {
- push_byte(parser, str, eat_byte(parser, c));
+ while ((c = peek_byte(reader)) && in_range(c, 'a', 'z')) {
+ push_byte(reader, str, eat_byte(reader, c));
}
- if (peek_byte(parser) == '-') {
- push_byte(parser, str, eat_byte(parser, '-'));
- while ((c = peek_byte(parser)) && (in_range(c, 'a', 'z') || in_range(c, '0', '9'))) {
- push_byte(parser, str, eat_byte(parser, c));
+ if (peek_byte(reader) == '-') {
+ push_byte(reader, str, eat_byte(reader, '-'));
+ while ((c = peek_byte(reader)) && (in_range(c, 'a', 'z') || in_range(c, '0', '9'))) {
+ push_byte(reader, str, eat_byte(reader, c));
}
}
return str;
@@ -786,49 +784,49 @@ read_language(SerdReader parser)
// [28] uriref ::= '<' relativeURI '>'
static Ref
-read_uriref(SerdReader parser)
+read_uriref(SerdReader reader)
{
- TRY_RET(eat_byte(parser, '<'));
- Ref const str = read_relativeURI(parser);
- if (str && eat_byte(parser, '>')) {
+ TRY_RET(eat_byte(reader, '<'));
+ Ref const str = read_relativeURI(reader);
+ if (str && eat_byte(reader, '>')) {
return str;
}
- pop_string(parser, str);
+ pop_string(reader, str);
return 0;
}
// [27] qname ::= prefixName? ':' name?
static Ref
-read_qname(SerdReader parser)
+read_qname(SerdReader reader)
{
- Ref prefix = read_prefixName(parser);
+ Ref prefix = read_prefixName(reader);
if (!prefix) {
- prefix = push_string(parser, "", 1);
+ prefix = push_string(reader, "", 1);
}
- TRY_THROW(eat_byte(parser, ':'));
- push_byte(parser, prefix, ':');
- Ref str = read_name(parser, prefix, false);
- if (parser->err) {
- pop_string(parser, prefix);
+ TRY_THROW(eat_byte(reader, ':'));
+ push_byte(reader, prefix, ':');
+ Ref str = read_name(reader, prefix, false);
+ if (reader->err) {
+ pop_string(reader, prefix);
return 0;
}
return str ? str : prefix;
except:
- pop_string(parser, prefix);
+ pop_string(reader, prefix);
return 0;
}
static Ref
-read_0_9(SerdReader parser, Ref str, bool at_least_one)
+read_0_9(SerdReader reader, Ref str, bool at_least_one)
{
uint8_t c;
if (at_least_one) {
- TRY_RET(in_range(c = peek_byte(parser), '0', '9'));
- push_byte(parser, str, eat_byte(parser, c));
+ TRY_RET(in_range(c = peek_byte(reader), '0', '9'));
+ push_byte(reader, str, eat_byte(reader, c));
}
- while (in_range((c = peek_byte(parser)), '0', '9')) {
- push_byte(parser, str, eat_byte(parser, c));
+ while (in_range((c = peek_byte(reader)), '0', '9')) {
+ push_byte(reader, str, eat_byte(reader, c));
}
return str;
}
@@ -842,62 +840,62 @@ read_0_9(SerdReader parser, Ref str, bool at_least_one)
// | ([0-9])+ exponent )
// [16] integer ::= ( '-' | '+' ) ? [0-9]+
static bool
-read_number(SerdReader parser, Node* dest)
+read_number(SerdReader reader, Node* dest)
{
#define XSD_DECIMAL "http://www.w3.org/2001/XMLSchema#decimal"
#define XSD_DOUBLE "http://www.w3.org/2001/XMLSchema#double"
#define XSD_INTEGER "http://www.w3.org/2001/XMLSchema#integer"
- Ref str = push_string(parser, "", 1);
- uint8_t c = peek_byte(parser);
+ Ref str = push_string(reader, "", 1);
+ uint8_t c = peek_byte(reader);
bool has_decimal = false;
Ref datatype = 0;
if (c == '-' || c == '+') {
- push_byte(parser, str, eat_byte(parser, c));
+ push_byte(reader, str, eat_byte(reader, c));
}
- if ((c = peek_byte(parser)) == '.') {
+ if ((c = peek_byte(reader)) == '.') {
has_decimal = true;
// decimal case 2 (e.g. '.0' or `-.0' or `+.0')
- push_byte(parser, str, eat_byte(parser, c));
- TRY_THROW(str = read_0_9(parser, str, true));
+ push_byte(reader, str, eat_byte(reader, c));
+ TRY_THROW(str = read_0_9(reader, str, true));
} else {
// all other cases ::= ( '-' | '+' ) [0-9]+ ( . )? ( [0-9]+ )? ...
- TRY_THROW(str = read_0_9(parser, str, true));
- if ((c = peek_byte(parser)) == '.') {
+ TRY_THROW(str = read_0_9(reader, str, true));
+ if ((c = peek_byte(reader)) == '.') {
has_decimal = true;
- push_byte(parser, str, eat_byte(parser, c));
- TRY_THROW(str = read_0_9(parser, str, false));
+ push_byte(reader, str, eat_byte(reader, c));
+ TRY_THROW(str = read_0_9(reader, str, false));
}
}
- c = peek_byte(parser);
+ c = peek_byte(reader);
if (c == 'e' || c == 'E') {
// double
- push_byte(parser, str, eat_byte(parser, c));
- str = read_0_9(parser, str, true);
- datatype = push_string(parser, XSD_DOUBLE, strlen(XSD_DOUBLE) + 1);
+ push_byte(reader, str, eat_byte(reader, c));
+ str = read_0_9(reader, str, true);
+ datatype = push_string(reader, XSD_DOUBLE, strlen(XSD_DOUBLE) + 1);
} else if (has_decimal) {
- datatype = push_string(parser, XSD_DECIMAL, strlen(XSD_DECIMAL) + 1);
+ datatype = push_string(reader, XSD_DECIMAL, strlen(XSD_DECIMAL) + 1);
} else {
- datatype = push_string(parser, XSD_INTEGER, strlen(XSD_INTEGER) + 1);
+ datatype = push_string(reader, XSD_INTEGER, strlen(XSD_INTEGER) + 1);
}
*dest = make_node(LITERAL, str, datatype, 0);
assert(dest->value);
return true;
except:
- pop_string(parser, datatype);
- pop_string(parser, str);
+ pop_string(reader, datatype);
+ pop_string(reader, str);
return false;
}
// [25] resource ::= uriref | qname
static bool
-read_resource(SerdReader parser, Node* dest)
+read_resource(SerdReader reader, Node* dest)
{
- switch (peek_byte(parser)) {
+ switch (peek_byte(reader)) {
case '<':
- *dest = make_node(URI, read_uriref(parser), 0, 0);
+ *dest = make_node(URI, read_uriref(reader), 0, 0);
break;
default:
- *dest = make_node(QNAME, read_qname(parser), 0, 0);
+ *dest = make_node(QNAME, read_qname(reader), 0, 0);
}
return (dest->value != 0);
}
@@ -905,113 +903,113 @@ read_resource(SerdReader parser, Node* dest)
// [14] literal ::= quotedString ( '@' language )? | datatypeSerdString
// | integer | double | decimal | boolean
static bool
-read_literal(SerdReader parser, Node* dest)
+read_literal(SerdReader reader, Node* dest)
{
Ref str = 0;
Node datatype = SERD_NODE_NULL;
- const uint8_t c = peek_byte(parser);
+ const uint8_t c = peek_byte(reader);
if (in_range(c, '0', '9') || c == '-' || c == '+') {
- return read_number(parser, dest);
+ return read_number(reader, dest);
} else if (c == '\"') {
- str = read_quotedString(parser);
+ str = read_quotedString(reader);
if (!str) {
return false;
}
Ref lang = 0;
- switch (peek_byte(parser)) {
+ switch (peek_byte(reader)) {
case '^':
- eat_byte(parser, '^');
- eat_byte(parser, '^');
- TRY_THROW(read_resource(parser, &datatype));
+ eat_byte(reader, '^');
+ eat_byte(reader, '^');
+ TRY_THROW(read_resource(reader, &datatype));
break;
case '@':
- eat_byte(parser, '@');
- TRY_THROW(lang = read_language(parser));
+ eat_byte(reader, '@');
+ TRY_THROW(lang = read_language(reader));
}
*dest = make_node(LITERAL, str, datatype.value, lang);
} else {
- *dest = make_node(QNAME, read_qname(parser), 0, 0);
+ *dest = make_node(QNAME, read_qname(reader), 0, 0);
}
return true;
except:
- pop_string(parser, str);
+ pop_string(reader, str);
return false;
}
// [12] predicate ::= resource
static bool
-read_predicate(SerdReader parser, Node* dest)
+read_predicate(SerdReader reader, Node* dest)
{
- return read_resource(parser, dest);
+ return read_resource(reader, dest);
}
// [9] verb ::= predicate | 'a'
static bool
-read_verb(SerdReader parser, Node* dest)
+read_verb(SerdReader reader, Node* dest)
{
#define RDF_TYPE "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"
uint8_t pre[2];
- readahead(parser, pre, 2);
+ readahead(reader, pre, 2);
switch (pre[0]) {
case 'a':
switch (pre[1]) {
case 0x9: case 0xA: case 0xD: case 0x20:
- eat_byte(parser, 'a');
- *dest = make_node(URI, push_string(parser, RDF_TYPE, 48), 0, 0);
+ eat_byte(reader, 'a');
+ *dest = make_node(URI, push_string(reader, RDF_TYPE, 48), 0, 0);
return true;
default: break; // fall through
}
default:
- return read_predicate(parser, dest);
+ return read_predicate(reader, dest);
}
}
// [26] nodeID ::= '_:' name
static Ref
-read_nodeID(SerdReader parser)
+read_nodeID(SerdReader reader)
{
- eat_byte(parser, '_');
- eat_byte(parser, ':');
- Ref str = push_string(parser, "", 1);
- return read_name(parser, str, true);
+ eat_byte(reader, '_');
+ eat_byte(reader, ':');
+ Ref str = push_string(reader, "", 1);
+ return read_name(reader, str, true);
}
static Ref
-blank_id(SerdReader parser)
+blank_id(SerdReader reader)
{
char str[32];
- const int len = snprintf(str, sizeof(str), "genid%u", parser->next_id++);
- return push_string(parser, str, len + 1);
+ const int len = snprintf(str, sizeof(str), "genid%u", reader->next_id++);
+ return push_string(reader, str, len + 1);
}
// Spec: [21] blank ::= nodeID | '[]' | '[' predicateObjectList ']' | collection
// Actual: [21] blank ::= nodeID | '[ ws* ]' | '[' ws* predicateObjectList ws* ']' | collection
static bool
-read_blank(SerdReader parser, Node* dest)
+read_blank(SerdReader reader, Node* dest)
{
- switch (peek_byte(parser)) {
+ switch (peek_byte(reader)) {
case '_':
- *dest = make_node(BLANK, read_nodeID(parser), 0, 0);
+ *dest = make_node(BLANK, read_nodeID(reader), 0, 0);
return true;
case '[':
- eat_byte(parser, '[');
- read_ws_star(parser);
- if (peek_byte(parser) == ']') {
- eat_byte(parser, ']');
- *dest = make_node(BLANK, blank_id(parser), 0, 0);
+ eat_byte(reader, '[');
+ read_ws_star(reader);
+ if (peek_byte(reader) == ']') {
+ eat_byte(reader, ']');
+ *dest = make_node(BLANK, blank_id(reader), 0, 0);
return true;
} else {
- *dest = make_node(BLANK, blank_id(parser), 0, 0);
- read_predicateObjectList(parser, dest);
- read_ws_star(parser);
- eat_byte(parser, ']');
+ *dest = make_node(BLANK, blank_id(reader), 0, 0);
+ read_predicateObjectList(reader, dest);
+ read_ws_star(reader);
+ eat_byte(reader, ']');
return true;
}
case '(':
- return read_collection(parser, dest);
+ return read_collection(reader, dest);
default:
- error(parser, "illegal blank node\n");
+ error(reader, "illegal blank node\n");
}
// TODO: collections
return false;
@@ -1030,32 +1028,32 @@ is_object_end(const uint8_t c)
}
// [13] object ::= resource | blank | literal
-// Recurses, calling statement_handler for every statement encountered.
+// Recurses, calling statement_sink for every statement encountered.
static bool
-read_object(SerdReader parser, const Node* subject, const Node* predicate)
+read_object(SerdReader reader, const Node* subject, const Node* predicate)
{
static const char* const XSD_BOOLEAN = "http://www.w3.org/2001/XMLSchema#boolean";
static const size_t XSD_BOOLEAN_LEN = 40;
bool ret = false;
Node o = SERD_NODE_NULL;
- const uint8_t c = peek_byte(parser);
+ const uint8_t c = peek_byte(reader);
switch (c) {
case ')':
return false;
case '[': case '(': case '_':
- TRY_THROW(ret = read_blank(parser, &o));
+ TRY_THROW(ret = read_blank(reader, &o));
break;
case '<': case ':':
- TRY_THROW(ret = read_resource(parser, &o));
+ TRY_THROW(ret = read_resource(reader, &o));
break;
case '\"': case '+': case '-':
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
- TRY_THROW(ret = read_literal(parser, &o));
+ TRY_THROW(ret = read_literal(reader, &o));
break;
case '.':
- TRY_THROW(ret = read_literal(parser, &o));
+ TRY_THROW(ret = read_literal(reader, &o));
default: break;
}
@@ -1066,48 +1064,48 @@ read_object(SerdReader parser, const Node* subject, const Node* predicate)
since `true' or `false' could be the start of a qname.
*/
uint8_t pre[6];
- readahead(parser, pre, 6);
+ readahead(reader, pre, 6);
if (!strncmp((char*)pre, "true", 4) && is_object_end(pre[4])) {
- eat_string(parser, "true", 4);
- const Ref value = push_string(parser, "true", 5);
- const Ref datatype = push_string(parser, XSD_BOOLEAN, XSD_BOOLEAN_LEN + 1);
+ eat_string(reader, "true", 4);
+ const Ref value = push_string(reader, "true", 5);
+ const Ref datatype = push_string(reader, XSD_BOOLEAN, XSD_BOOLEAN_LEN + 1);
o = make_node(LITERAL, value, datatype, 0);
} else if (!strncmp((char*)pre, "false", 5) && is_object_end(pre[5])) {
- eat_string(parser, "false", 5);
- const Ref value = push_string(parser, "false", 6);
- const Ref datatype = push_string(parser, XSD_BOOLEAN, XSD_BOOLEAN_LEN + 1);
+ eat_string(reader, "false", 5);
+ const Ref value = push_string(reader, "false", 6);
+ const Ref datatype = push_string(reader, XSD_BOOLEAN, XSD_BOOLEAN_LEN + 1);
o = make_node(LITERAL, value, datatype, 0);
} else if (!is_object_end(c)) {
- o = make_node(QNAME, read_qname(parser), 0, 0);
+ o = make_node(QNAME, read_qname(reader), 0, 0);
}
}
if (o.value != 0) {
- emit_statement(parser, NULL, subject, predicate, &o);
- pop_string(parser, o.lang);
- pop_string(parser, o.datatype);
- pop_string(parser, o.value);
+ emit_statement(reader, NULL, subject, predicate, &o);
+ pop_string(reader, o.lang);
+ pop_string(reader, o.datatype);
+ pop_string(reader, o.value);
return true;
}
except:
- pop_string(parser, o.lang);
- pop_string(parser, o.datatype);
- pop_string(parser, o.value);
+ pop_string(reader, o.lang);
+ pop_string(reader, o.datatype);
+ pop_string(reader, o.value);
return false;
}
// Spec: [8] objectList ::= object ( ',' object )*
// Actual: [8] objectList ::= object ( ws* ',' ws* object )*
static bool
-read_objectList(SerdReader parser, const Node* subject, const Node* predicate)
+read_objectList(SerdReader reader, const Node* subject, const Node* predicate)
{
- TRY_RET(read_object(parser, subject, predicate));
- read_ws_star(parser);
- while (peek_byte(parser) == ',') {
- eat_byte(parser, ',');
- read_ws_star(parser);
- TRY_RET(read_object(parser, subject, predicate));
- read_ws_star(parser);
+ TRY_RET(read_object(reader, subject, predicate));
+ read_ws_star(reader);
+ while (peek_byte(reader) == ',') {
+ eat_byte(reader, ',');
+ read_ws_star(reader);
+ TRY_RET(read_object(reader, subject, predicate));
+ read_ws_star(reader);
}
return true;
}
@@ -1115,57 +1113,57 @@ read_objectList(SerdReader parser, const Node* subject, const Node* predicate)
// Spec: [7] predicateObjectList ::= verb objectList ( ';' verb objectList )* ( ';' )?
// Actual: [7] predicateObjectList ::= verb ws+ objectList ( ws* ';' ws* verb ws+ objectList )* ( ';' )?
static bool
-read_predicateObjectList(SerdReader parser, const Node* subject)
+read_predicateObjectList(SerdReader reader, const Node* subject)
{
- if (parser->eof) {
+ if (reader->eof) {
return false;
}
Node predicate = SERD_NODE_NULL;
- TRY_RET(read_verb(parser, &predicate));
- TRY_THROW(read_ws_plus(parser));
- TRY_THROW(read_objectList(parser, subject, &predicate));
- pop_string(parser, predicate.value);
+ TRY_RET(read_verb(reader, &predicate));
+ TRY_THROW(read_ws_plus(reader));
+ TRY_THROW(read_objectList(reader, subject, &predicate));
+ pop_string(reader, predicate.value);
predicate.value = 0;
- read_ws_star(parser);
- while (peek_byte(parser) == ';') {
- eat_byte(parser, ';');
- read_ws_star(parser);
- switch (peek_byte(parser)) {
+ read_ws_star(reader);
+ while (peek_byte(reader) == ';') {
+ eat_byte(reader, ';');
+ read_ws_star(reader);
+ switch (peek_byte(reader)) {
case '.': case ']':
return true;
default:
- TRY_THROW(read_verb(parser, &predicate));
- TRY_THROW(read_ws_plus(parser));
- TRY_THROW(read_objectList(parser, subject, &predicate));
- pop_string(parser, predicate.value);
+ TRY_THROW(read_verb(reader, &predicate));
+ TRY_THROW(read_ws_plus(reader));
+ TRY_THROW(read_objectList(reader, subject, &predicate));
+ pop_string(reader, predicate.value);
predicate.value = 0;
- read_ws_star(parser);
+ read_ws_star(reader);
}
}
return true;
except:
- pop_string(parser, predicate.value);
+ pop_string(reader, predicate.value);
return false;
}
/** Recursive helper for read_collection. */
static bool
-read_collection_rec(SerdReader parser, const Node* head)
+read_collection_rec(SerdReader reader, const Node* head)
{
- read_ws_star(parser);
- if (peek_byte(parser) == ')') {
- eat_byte(parser, ')');
- emit_statement(parser, NULL, head, &parser->rdf_rest, &parser->rdf_nil);
+ read_ws_star(reader);
+ if (peek_byte(reader) == ')') {
+ eat_byte(reader, ')');
+ emit_statement(reader, NULL, head, &reader->rdf_rest, &reader->rdf_nil);
return false;
} else {
- const Node rest = make_node(BLANK, blank_id(parser), 0, 0);
- emit_statement(parser, NULL, head, &parser->rdf_rest, &rest);
- if (read_object(parser, &rest, &parser->rdf_first)) {
- read_collection_rec(parser, &rest);
- pop_string(parser, rest.value);
+ const Node rest = make_node(BLANK, blank_id(reader), 0, 0);
+ emit_statement(reader, NULL, head, &reader->rdf_rest, &rest);
+ if (read_object(reader, &rest, &reader->rdf_first)) {
+ read_collection_rec(reader, &rest);
+ pop_string(reader, rest.value);
return true;
} else {
- pop_string(parser, rest.value);
+ pop_string(reader, rest.value);
return false;
}
}
@@ -1174,36 +1172,36 @@ read_collection_rec(SerdReader parser, const Node* head)
// [22] itemList ::= object+
// [23] collection ::= '(' itemList? ')'
static bool
-read_collection(SerdReader parser, Node* dest)
+read_collection(SerdReader reader, Node* dest)
{
- TRY_RET(eat_byte(parser, '('));
- read_ws_star(parser);
- if (peek_byte(parser) == ')') { // Empty collection
- eat_byte(parser, ')');
- *dest = parser->rdf_nil;
+ TRY_RET(eat_byte(reader, '('));
+ read_ws_star(reader);
+ if (peek_byte(reader) == ')') { // Empty collection
+ eat_byte(reader, ')');
+ *dest = reader->rdf_nil;
return true;
}
- *dest = make_node(BLANK, blank_id(parser), 0, 0);
- if (!read_object(parser, dest, &parser->rdf_first)) {
- pop_string(parser, dest->value);
- return error(parser, "unexpected end of collection\n");
+ *dest = make_node(BLANK, blank_id(reader), 0, 0);
+ if (!read_object(reader, dest, &reader->rdf_first)) {
+ pop_string(reader, dest->value);
+ return error(reader, "unexpected end of collection\n");
}
- return read_collection_rec(parser, dest);
+ return read_collection_rec(reader, dest);
}
// [11] subject ::= resource | blank
static Node
-read_subject(SerdReader parser)
+read_subject(SerdReader reader)
{
Node subject = SERD_NODE_NULL;
- switch (peek_byte(parser)) {
+ switch (peek_byte(reader)) {
case '[': case '(': case '_':
- read_blank(parser, &subject);
+ read_blank(reader, &subject);
break;
default:
- read_resource(parser, &subject);
+ read_resource(reader, &subject);
}
return subject;
}
@@ -1211,13 +1209,13 @@ read_subject(SerdReader parser)
// Spec: [6] triples ::= subject predicateObjectList
// Actual: [6] triples ::= subject ws+ predicateObjectList
static bool
-read_triples(SerdReader parser)
+read_triples(SerdReader reader)
{
- const Node subject = read_subject(parser);
+ const Node subject = read_subject(reader);
if (subject.value != 0) {
- TRY_RET(read_ws_plus(parser));
- const bool ret = read_predicateObjectList(parser, &subject);
- pop_string(parser, subject.value);
+ TRY_RET(read_ws_plus(reader));
+ const bool ret = read_predicateObjectList(reader, &subject);
+ pop_string(reader, subject.value);
return ret;
}
return false;
@@ -1225,117 +1223,117 @@ read_triples(SerdReader parser)
// [5] base ::= '@base' ws+ uriref
static bool
-read_base(SerdReader parser)
+read_base(SerdReader reader)
{
// `@' is already eaten in read_directive
- eat_string(parser, "base", 4);
- TRY_RET(read_ws_plus(parser));
+ eat_string(reader, "base", 4);
+ TRY_RET(read_ws_plus(reader));
Ref uri;
- TRY_RET(uri = read_uriref(parser));
- parser->base_handler(parser->handle, deref(parser, uri));
- pop_string(parser, uri);
+ TRY_RET(uri = read_uriref(reader));
+ reader->base_sink(reader->handle, deref(reader, uri));
+ pop_string(reader, uri);
return true;
}
// Spec: [4] prefixID ::= '@prefix' ws+ prefixName? ':' uriref
// Actual: [4] prefixID ::= '@prefix' ws+ prefixName? ':' ws* uriref
static bool
-read_prefixID(SerdReader parser)
+read_prefixID(SerdReader reader)
{
// `@' is already eaten in read_directive
- eat_string(parser, "prefix", 6);
- TRY_RET(read_ws_plus(parser));
+ eat_string(reader, "prefix", 6);
+ TRY_RET(read_ws_plus(reader));
bool ret = false;
- Ref name = read_prefixName(parser);
+ Ref name = read_prefixName(reader);
if (!name) {
- name = push_string(parser, "", 1);
+ name = push_string(reader, "", 1);
}
- TRY_THROW(eat_byte(parser, ':') == ':');
- read_ws_star(parser);
+ TRY_THROW(eat_byte(reader, ':') == ':');
+ read_ws_star(reader);
Ref uri = 0;
- TRY_THROW(uri = read_uriref(parser));
- ret = parser->prefix_handler(parser->handle,
- deref(parser, name),
- deref(parser, uri));
- pop_string(parser, uri);
+ TRY_THROW(uri = read_uriref(reader));
+ ret = reader->prefix_sink(reader->handle,
+ deref(reader, name),
+ deref(reader, uri));
+ pop_string(reader, uri);
except:
- pop_string(parser, name);
+ pop_string(reader, name);
return ret;
}
// [3] directive ::= prefixID | base
static bool
-read_directive(SerdReader parser)
+read_directive(SerdReader reader)
{
- eat_byte(parser, '@');
- switch (peek_byte(parser)) {
+ eat_byte(reader, '@');
+ switch (peek_byte(reader)) {
case 'b':
- return read_base(parser);
+ return read_base(reader);
case 'p':
- return read_prefixID(parser);
+ return read_prefixID(reader);
default:
- return error(parser, "illegal directive\n");
+ return error(reader, "illegal directive\n");
}
}
// Spec: [1] statement ::= directive '.' | triples '.' | ws+
// Actual: [1] statement ::= directive ws* '.' | triples ws* '.' | ws+
static bool
-read_statement(SerdReader parser)
+read_statement(SerdReader reader)
{
- read_ws_star(parser);
- if (parser->eof) {
+ read_ws_star(reader);
+ if (reader->eof) {
return true;
}
- switch (peek_byte(parser)) {
+ switch (peek_byte(reader)) {
case '@':
- TRY_RET(read_directive(parser));
+ TRY_RET(read_directive(reader));
break;
default:
- TRY_RET(read_triples(parser));
+ TRY_RET(read_triples(reader));
break;
}
- read_ws_star(parser);
- return eat_byte(parser, '.');
+ read_ws_star(reader);
+ return eat_byte(reader, '.');
}
// [1] turtleDoc ::= statement
static bool
-read_turtleDoc(SerdReader parser)
+read_turtleDoc(SerdReader reader)
{
- while (!parser->err && !parser->eof) {
- TRY_RET(read_statement(parser));
+ while (!reader->err && !reader->eof) {
+ TRY_RET(read_statement(reader));
}
- return !parser->err;
+ return !reader->err;
}
SERD_API
SerdReader
-serd_reader_new(SerdSyntax syntax,
- void* handle,
- SerdBaseHandler base_handler,
- SerdPrefixHandler prefix_handler,
- SerdStatementHandler statement_handler)
+serd_reader_new(SerdSyntax syntax,
+ void* handle,
+ SerdBaseSink base_sink,
+ SerdPrefixSink prefix_sink,
+ SerdStatementSink statement_sink)
{
const Cursor cur = { NULL, 0, 0 };
SerdReader reader = malloc(sizeof(struct SerdReaderImpl));
- reader->handle = handle;
- reader->base_handler = base_handler;
- reader->prefix_handler = prefix_handler;
- reader->statement_handler = statement_handler;
- reader->fd = 0;
- reader->stack.buf = malloc(STACK_CHUNK_SIZE);
- reader->stack.buf_size = STACK_CHUNK_SIZE;
- reader->stack.size = 8;
- reader->cur = cur;
- reader->next_id = 1;
- reader->err = 0;
- reader->read_buf = (uint8_t*)malloc(READ_BUF_LEN * 2);
- reader->read_head = 0;
- reader->eof = false;
+ reader->handle = handle;
+ reader->base_sink = base_sink;
+ reader->prefix_sink = prefix_sink;
+ reader->statement_sink = statement_sink;
+ reader->fd = 0;
+ reader->stack.buf = malloc(STACK_CHUNK_SIZE);
+ reader->stack.buf_size = STACK_CHUNK_SIZE;
+ reader->stack.size = 8;
+ reader->cur = cur;
+ reader->next_id = 1;
+ reader->err = 0;
+ reader->read_buf = (uint8_t*)malloc(READ_BUF_LEN * 2);
+ reader->read_head = 0;
+ reader->eof = false;
#ifdef STACK_DEBUG
- reader->alloc_stack = 0;
- reader->n_allocs = 0;
+ reader->alloc_stack = 0;
+ reader->n_allocs = 0;
#endif
memset(reader->read_buf, '\0', READ_BUF_LEN * 2);