diff options
Diffstat (limited to 'core.lv2/serd-0.1.0.c')
| -rw-r--r-- | core.lv2/serd-0.1.0.c | 2700 |
1 files changed, 2700 insertions, 0 deletions
diff --git a/core.lv2/serd-0.1.0.c b/core.lv2/serd-0.1.0.c new file mode 100644 index 0000000..413fedb --- /dev/null +++ b/core.lv2/serd-0.1.0.c @@ -0,0 +1,2700 @@ +/* + Copyright 2011 David Robillard <http://drobilla.net> + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, + INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, + OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#ifndef SERD_INTERNAL_H +#define SERD_INTERNAL_H + +#include <assert.h> +#include <stdlib.h> + +#include "serd/serd.h" + +/** A dynamic stack in memory. */ +typedef struct { + uint8_t* buf; ///< Stack memory + size_t buf_size; ///< Allocated size of buf (>= size) + size_t size; ///< Conceptual size of stack in buf +} SerdStack; + +/** An offset to start the stack at. Note 0 is reserved for NULL. */ +#define SERD_STACK_BOTTOM sizeof(void*) + +static inline SerdStack +serd_stack_new(size_t size) +{ + SerdStack stack; + stack.buf = malloc(size); + stack.buf_size = size; + stack.size = SERD_STACK_BOTTOM; + return stack; +} + +static inline bool +serd_stack_is_empty(SerdStack* stack) +{ + return stack->size <= SERD_STACK_BOTTOM; +} + +static inline void +serd_stack_free(SerdStack* stack) +{ + free(stack->buf); + stack->buf = NULL; + stack->buf_size = 0; + stack->size = 0; +} + +static inline uint8_t* +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 *= 2; + stack->buf = realloc(stack->buf, stack->buf_size); + } + uint8_t* const ret = (stack->buf + stack->size); + stack->size = new_size; + return ret; +} + +static inline void +serd_stack_pop(SerdStack* stack, size_t n_bytes) +{ + assert(stack->size >= n_bytes); + stack->size -= n_bytes; +} + +/** Return true if @a c lies within [min...max] (inclusive) */ +static inline bool +in_range(const uint8_t c, const uint8_t min, const uint8_t max) +{ + return (c >= min && c <= max); +} + +/** RFC2234: ALPHA := %x41-5A / %x61-7A ; A-Z / a-z */ +static inline bool +is_alpha(const uint8_t c) +{ + return in_range(c, 'A', 'Z') || in_range(c, 'a', 'z'); +} + +/** RFC2234: DIGIT ::= %x30-39 ; 0-9 */ +static inline bool +is_digit(const uint8_t c) +{ + return in_range(c, '0', '9'); +} + +/** UTF-8 strlen. + * @return Lengh of @a utf8 in characters. + * @param utf8 A null-terminated UTF-8 string. + * @param out_n_bytes (Output) Set to the size of @a utf8 in bytes. + */ +static inline size_t +serd_strlen(const uint8_t* utf8, size_t* out_n_bytes) +{ + size_t n_chars = 0; + size_t i = 0; + for (; utf8[i]; ++i) { + if ((utf8[i] & 0xC0) != 0x80) { + // Does not start with `10', start of a new character + ++n_chars; + } + } + if (out_n_bytes) { + *out_n_bytes = i + 1; + } + return n_chars; +} + +#endif // SERD_INTERNAL_H + +/** + * @file env.c + */ + +#include <assert.h> +#include <stdbool.h> +#include <stdlib.h> +#include <string.h> + + +typedef struct { + SerdNode name; + SerdNode uri; +} SerdPrefix; + +struct SerdEnvImpl { + SerdPrefix* prefixes; + size_t n_prefixes; +}; + +SERD_API +SerdEnv +serd_env_new() +{ + SerdEnv env = malloc(sizeof(struct SerdEnvImpl)); + env->prefixes = NULL; + env->n_prefixes = 0; + return env; +} + +SERD_API +void +serd_env_free(SerdEnv env) +{ + for (size_t i = 0; i < env->n_prefixes; ++i) { + serd_node_free(&env->prefixes[i].name); + serd_node_free(&env->prefixes[i].uri); + } + free(env->prefixes); + free(env); +} + +static inline SerdPrefix* +serd_env_find(SerdEnv env, + const uint8_t* name, + size_t name_len) +{ + for (size_t i = 0; i < env->n_prefixes; ++i) { + const SerdNode* const prefix_name = &env->prefixes[i].name; + if (prefix_name->n_bytes == name_len + 1) { + if (!memcmp(prefix_name->buf, name, name_len)) { + return &env->prefixes[i]; + } + } + } + return NULL; +} + +SERD_API +void +serd_env_add(SerdEnv env, + const SerdNode* name, + const SerdNode* uri) +{ + assert(name && uri); + SerdPrefix* const prefix = serd_env_find(env, name->buf, name->n_chars); + if (prefix) { + serd_node_free(&prefix->uri); + prefix->uri = serd_node_copy(uri); + } else { + env->prefixes = realloc(env->prefixes, + (++env->n_prefixes) * sizeof(SerdPrefix)); + env->prefixes[env->n_prefixes - 1].name = serd_node_copy(name); + env->prefixes[env->n_prefixes - 1].uri = serd_node_copy(uri); + } +} + +SERD_API +bool +serd_env_qualify(const SerdEnv env, + const SerdNode* uri, + SerdNode* prefix_name, + SerdChunk* suffix) +{ + for (size_t i = 0; i < env->n_prefixes; ++i) { + const SerdNode* const prefix_uri = &env->prefixes[i].uri; + if (uri->n_bytes >= prefix_uri->n_bytes) { + if (!strncmp((const char*)uri->buf, + (const char*)prefix_uri->buf, + prefix_uri->n_bytes - 1)) { + *prefix_name = env->prefixes[i].name; + suffix->buf = uri->buf + prefix_uri->n_bytes - 1; + suffix->len = uri->n_bytes - prefix_uri->n_bytes; + return true; + } + } + } + return false; +} + +SERD_API +bool +serd_env_expand(const SerdEnv env, + const SerdNode* qname, + SerdChunk* uri_prefix, + SerdChunk* uri_suffix) +{ + const uint8_t* const colon = memchr(qname->buf, ':', qname->n_bytes); + if (!colon) { + return false; // Illegal qname + } + + const size_t name_len = colon - qname->buf; + const SerdPrefix* const prefix = serd_env_find(env, qname->buf, name_len); + if (prefix) { + uri_prefix->buf = prefix->uri.buf; + uri_prefix->len = prefix->uri.n_bytes - 1; + uri_suffix->buf = colon + 1; + uri_suffix->len = qname->n_bytes - (colon - qname->buf) - 2; + return true; + } + return false; +} + +SERD_API +void +serd_env_foreach(const SerdEnv env, + SerdPrefixSink func, + void* handle) +{ + for (size_t i = 0; i < env->n_prefixes; ++i) { + func(handle, + &env->prefixes[i].name, + &env->prefixes[i].uri); + } +} + +/** + * @file node.c + */ + +#include <stdlib.h> +#include <string.h> + + +SERD_API +SerdNode +serd_node_from_string(SerdType type, const uint8_t* buf) +{ + size_t buf_n_bytes; + const size_t buf_n_chars = serd_strlen(buf, &buf_n_bytes); + SerdNode ret = { type, buf_n_bytes, buf_n_chars, buf }; + return ret; +} + +SERD_API +SerdNode +serd_node_copy(const SerdNode* node) +{ + SerdNode copy = *node; + uint8_t* buf = malloc(copy.n_bytes); + memcpy(buf, node->buf, copy.n_bytes); + copy.buf = buf; + return copy; +} + +static size_t +serd_uri_string_length(const SerdURI* uri) +{ + size_t len = uri->path_base.len; + +#define ADD_LEN(field, n_delims) \ + if ((field).len) { len += (field).len + (n_delims); } + + ADD_LEN(uri->path, 1); // + possible leading `/' + ADD_LEN(uri->scheme, 1); // + trailing `:' + ADD_LEN(uri->authority, 2); // + leading `//' + ADD_LEN(uri->query, 1); // + leading `?' + ADD_LEN(uri->fragment, 1); // + leading `#' + + // Add 2 for authority // prefix (added even though authority.len = 0) + return len + 2; // + 2 for authority // +} + +static size_t +string_sink(const void* buf, size_t len, void* stream) +{ + uint8_t** ptr = (uint8_t**)stream; + memcpy(*ptr, buf, len); + *ptr += len; + return len; +} + +SERD_API +SerdNode +serd_node_new_uri_from_node(const SerdNode* uri_node, + const SerdURI* base, + SerdURI* out) +{ + return serd_node_new_uri_from_string(uri_node->buf, base, out); +} + +SERD_API +SerdNode +serd_node_new_uri_from_string(const uint8_t* str, + const SerdURI* base, + SerdURI* out) +{ + if (str[0] == '\0') { + return serd_node_new_uri(base, NULL, out); // Empty URI => Base URI + } else { + SerdURI uri; + if (serd_uri_parse(str, &uri)) { + return serd_node_new_uri(&uri, base, out); // Resolve/Serialise + } + } + return SERD_NODE_NULL; +} + +SERD_API +SerdNode +serd_node_new_uri(const SerdURI* uri, const SerdURI* base, SerdURI* out) +{ + SerdURI abs_uri = *uri; + if (base) { + serd_uri_resolve(uri, base, &abs_uri); + } + + const size_t len = serd_uri_string_length(&abs_uri); + uint8_t* buf = malloc(len + 1); + + SerdNode node = { SERD_URI, len + 1, len, buf }; // FIXME: UTF-8 + + uint8_t* ptr = buf; + const size_t actual_len = serd_uri_serialise(&abs_uri, string_sink, &ptr); + + buf[actual_len] = '\0'; + node.n_bytes = actual_len + 1; + node.n_chars = actual_len; + + // FIXME: double parse + if (!serd_uri_parse(buf, out)) { + fprintf(stderr, "error parsing URI\n"); + return SERD_NODE_NULL; + } + + return node; +} + +SERD_API +void +serd_node_free(SerdNode* node) +{ + free((uint8_t*)node->buf); +} + +/** + * @file reader.c + */ + +#include <assert.h> +#include <stdarg.h> +#include <stdbool.h> +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + + +#define NS_XSD "http://www.w3.org/2001/XMLSchema#" +#define NS_RDF "http://www.w3.org/1999/02/22-rdf-syntax-ns#" + +#define TRY_THROW(exp) if (!(exp)) goto except; +#define TRY_RET(exp) if (!(exp)) return 0; + +#define STACK_PAGE_SIZE 4096 +#define READ_BUF_LEN 4096 + +typedef struct { + const uint8_t* filename; + unsigned line; + unsigned col; +} Cursor; + +typedef uint32_t uchar; + +typedef size_t Ref; + +typedef struct { + SerdType type; + Ref value; + Ref datatype; + Ref lang; +} Node; + +typedef struct { + const Node* graph; + const Node* subject; + const Node* predicate; +} ReadContext; + +/** Measured UTF-8 string. */ +typedef struct { + size_t n_bytes; ///< Size in bytes including trailing null byte + size_t n_chars; ///< Length in characters + uint8_t buf[]; ///< Buffer +} SerdString; + +static const Node INTERNAL_NODE_NULL = { 0, 0, 0, 0 }; + +struct SerdReaderImpl { + void* handle; + SerdBaseSink base_sink; + SerdPrefixSink prefix_sink; + SerdStatementSink statement_sink; + SerdEndSink end_sink; + Node rdf_type; + Node rdf_first; + Node rdf_rest; + Node rdf_nil; + FILE* fd; + SerdStack stack; + Cursor cur; + uint8_t* buf; + const uint8_t* blank_prefix; + unsigned next_id; + int err; + uint8_t* read_buf; + int32_t read_head; ///< Offset into read_buf + bool from_file; ///< True iff reading from @ref fd + bool eof; +#ifdef SUIL_STACK_CHECK + Ref* alloc_stack; ///< Stack of push offsets + size_t n_allocs; ///< Number of stack pushes +#endif +}; + +struct SerdReadStateImpl { + SerdEnv env; + SerdNode base_uri_node; + SerdURI base_uri; +}; + +typedef enum { + SERD_SUCCESS = 0, ///< Completed successfully + SERD_FAILURE = 1, ///< Non-fatal failure + SERD_ERROR = 2, ///< Fatal error +} SerdStatus; + +static inline int +error(SerdReader reader, const char* fmt, ...) +{ + va_list args; + va_start(args, fmt); + fprintf(stderr, "error: %s:%u:%u: ", + reader->cur.filename, reader->cur.line, reader->cur.col); + vfprintf(stderr, fmt, args); + return 0; +} + +static Node +make_node(SerdType type, Ref value, Ref datatype, Ref lang) +{ + const Node ret = { type, value, datatype, lang }; + return ret; +} + +static inline bool +page(SerdReader reader) +{ + assert(reader->from_file); + reader->read_head = 0; + const size_t n_read = fread(reader->read_buf, 1, READ_BUF_LEN, reader->fd); + if (n_read == 0) { + reader->read_buf[0] = '\0'; + reader->eof = true; + return false; + } else if (n_read < READ_BUF_LEN) { + reader->read_buf[n_read] = '\0'; + } + return true; +} + +static inline bool +peek_string(SerdReader reader, uint8_t* pre, int n) +{ + uint8_t* ptr = reader->read_buf + reader->read_head; + for (int i = 0; i < n; ++i) { + if (reader->from_file && (reader->read_head + i >= READ_BUF_LEN)) { + if (!page(reader)) { + return false; + } + 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; + } + } + return true; +} + +static inline uint8_t +peek_byte(SerdReader reader) +{ + return reader->read_buf[reader->read_head]; +} + +static inline uint8_t +eat_byte(SerdReader reader, const uint8_t byte) +{ + const uint8_t c = peek_byte(reader); + ++reader->read_head; + switch (c) { + case '\n': ++reader->cur.line; reader->cur.col = 0; break; + default: ++reader->cur.col; + } + + if (c != byte) { + return error(reader, "expected `%c', not `%c'\n", byte, c); + } + if (reader->from_file && (reader->read_head == READ_BUF_LEN)) { + TRY_RET(page(reader)); + 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 reader, const char* str, unsigned n) +{ + for (unsigned i = 0; i < n; ++i) { + eat_byte(reader, ((const uint8_t*)str)[i]); + } +} + +#ifdef SUIL_STACK_CHECK +static inline bool +stack_is_top_string(SerdReader reader, Ref ref) +{ + return ref == reader->alloc_stack[reader->n_allocs - 1]; +} +#endif + +static inline intptr_t +pad_size(intptr_t size) +{ + return (size + 7) & (~7); +} + +// Make a new string from a non-UTF-8 C string (internal use only) +static Ref +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)reader->stack.size); + const size_t pad = stack_size - reader->stack.size; + uint8_t* mem = serd_stack_push( + &reader->stack, pad + sizeof(SerdString) + n_bytes) + pad; + SerdString* const str = (SerdString*)mem; + str->n_bytes = n_bytes; + str->n_chars = n_bytes - 1; + memcpy(str->buf, c_str, n_bytes); +#ifdef SUIL_STACK_CHECK + reader->alloc_stack = realloc(reader->alloc_stack, + sizeof(uint8_t*) * (++reader->n_allocs)); + reader->alloc_stack[reader->n_allocs - 1] = (mem - reader->stack.buf); +#endif + return (uint8_t*)str - reader->stack.buf; +} + +static inline SerdString* +deref(SerdReader reader, const Ref ref) +{ + if (ref) { + return (SerdString*)(reader->stack.buf + ref); + } + return NULL; +} + +static inline void +push_byte(SerdReader reader, Ref ref, const uint8_t c) +{ + #ifdef SUIL_STACK_CHECK + assert(stack_is_top_string(reader, ref)); + #endif + serd_stack_push(&reader->stack, 1); + SerdString* const str = deref(reader, ref); + ++str->n_bytes; + if ((c & 0xC0) != 0x80) { + // Does not start with `10', start of a new character + ++str->n_chars; + } + assert(str->n_bytes > str->n_chars); + str->buf[str->n_bytes - 2] = c; + str->buf[str->n_bytes - 1] = '\0'; +} + +static void +pop_string(SerdReader reader, Ref ref) +{ + if (ref) { + if (ref == reader->rdf_nil.value + || ref == reader->rdf_first.value + || ref == reader->rdf_rest.value) { + return; + } + #ifdef SUIL_STACK_CHECK + 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(reader, reader->alloc_stack[reader->n_allocs - 1])->buf); + } + assert(stack_is_top_string(reader, ref)); + --reader->n_allocs; + #endif + serd_stack_pop(&reader->stack, deref(reader, ref)->n_bytes); + } +} + +static inline SerdNode +public_node_from_ref(SerdReader reader, SerdType type, Ref ref) +{ + if (!ref) { + return SERD_NODE_NULL; + } + const SerdString* str = deref(reader, ref); + const SerdNode public = { type, str->n_bytes, str->n_chars, str->buf }; + return public; +} + +static inline SerdNode +public_node(SerdReader reader, const Node* private) +{ + return public_node_from_ref(reader, private->type, private->value); +} + + +static inline bool +emit_statement(SerdReader reader, + const Node* g, const Node* s, const Node* p, const Node* o) +{ + assert(s->value && p->value && o->value); + const SerdNode graph = g ? public_node(reader, g) : SERD_NODE_NULL; + const SerdNode subject = public_node(reader, s); + const SerdNode predicate = public_node(reader, p); + const SerdNode object = public_node(reader, o); + const SerdNode object_datatype = public_node_from_ref(reader, SERD_URI, o->datatype); + const SerdNode object_lang = public_node_from_ref(reader, SERD_LITERAL, o->lang); + return reader->statement_sink(reader->handle, + &graph, + &subject, + &predicate, + &object, + &object_datatype, + &object_lang); +} + +static bool read_collection(SerdReader reader, ReadContext ctx, Node* dest); +static bool read_predicateObjectList(SerdReader reader, ReadContext ctx); + +// [40] hex ::= [#x30-#x39] | [#x41-#x46] +static inline uint8_t +read_hex(SerdReader reader) +{ + const uint8_t c = peek_byte(reader); + if (in_range(c, 0x30, 0x39) || in_range(c, 0x41, 0x46)) { + return eat_byte(reader, c); + } else { + return error(reader, "illegal hexadecimal digit `%c'\n", c); + } +} + +static inline bool +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(reader); + } + + uint32_t c; + sscanf((const char*)buf, "%X", &c); + + unsigned size = 0; + if (c < 0x00000080) { + size = 1; + } else if (c < 0x00000800) { + size = 2; + } else if (c < 0x00010000) { + size = 3; + } else if (c < 0x00200000) { + size = 4; + } else { + return false; + } + + // Build output in buf + // (Note # of bytes = # of leading 1 bits in first byte) + switch (size) { + case 4: + buf[3] = 0x80 | (uint8_t)(c & 0x3F); + c >>= 6; + c |= (16 << 12); // set bit 4 + case 3: + buf[2] = 0x80 | (uint8_t)(c & 0x3F); + c >>= 6; + c |= (32 << 6); // set bit 5 + case 2: + buf[1] = 0x80 | (uint8_t)(c & 0x3F); + c >>= 6; + c |= 0xC0; // set bits 6 and 7 + case 1: + buf[0] = (uint8_t)c; + } + + for (unsigned i = 0; i < size; ++i) { + push_byte(reader, dest, buf[i]); + } + return true; +} + +static inline bool +read_character_escape(SerdReader reader, Ref dest) +{ + switch (peek_byte(reader)) { + case '\\': + push_byte(reader, dest, eat_byte(reader, '\\')); + return true; + case 'u': + eat_byte(reader, 'u'); + return read_hex_escape(reader, 4, dest); + case 'U': + eat_byte(reader, 'U'); + return read_hex_escape(reader, 8, dest); + default: + return false; + } +} + +static inline bool +read_echaracter_escape(SerdReader reader, Ref dest) +{ + switch (peek_byte(reader)) { + case 't': + eat_byte(reader, 't'); + push_byte(reader, dest, '\t'); + return true; + case 'n': + eat_byte(reader, 'n'); + push_byte(reader, dest, '\n'); + return true; + case 'r': + eat_byte(reader, 'r'); + push_byte(reader, dest, '\r'); + return true; + default: + return read_character_escape(reader, dest); + } +} + +static inline bool +read_scharacter_escape(SerdReader reader, Ref dest) +{ + switch (peek_byte(reader)) { + case '"': + push_byte(reader, dest, eat_byte(reader, '"')); + return true; + default: + return read_echaracter_escape(reader, dest); + } +} + +static inline bool +read_ucharacter_escape(SerdReader reader, Ref dest) +{ + switch (peek_byte(reader)) { + case '>': + push_byte(reader, dest, eat_byte(reader, '>')); + return true; + default: + return read_echaracter_escape(reader, dest); + } +} + +// [38] character ::= '\u' hex hex hex hex +// | '\U' hex hex hex hex hex hex hex hex +// | '\\' +// | [#x20-#x5B] | [#x5D-#x10FFFF] +static inline SerdStatus +read_character(SerdReader reader, Ref dest) +{ + const uint8_t c = peek_byte(reader); + assert(c != '\\'); // Only called from methods that handle escapes first + switch (c) { + case '\0': + error(reader, "unexpected end of file\n", peek_byte(reader)); + return SERD_ERROR; + default: + if (c < 0x20) { // ASCII control character + error(reader, "unexpected control character\n"); + return SERD_ERROR; + } else if (c <= 0x7E) { // Printable ASCII + push_byte(reader, dest, eat_byte(reader, c)); + return SERD_SUCCESS; + } else { // Wide UTF-8 character + unsigned size = 1; + if ((c & 0xE0) == 0xC0) { // Starts with `110' + size = 2; + } else if ((c & 0xF0) == 0xE0) { // Starts with `1110' + size = 3; + } else if ((c & 0xF8) == 0xF0) { // Starts with `11110' + size = 4; + } else { + error(reader, "invalid character\n"); + return SERD_ERROR; + } + for (unsigned i = 0; i < size; ++i) { + push_byte(reader, dest, eat_byte(reader, peek_byte(reader))); + } + return SERD_SUCCESS; + } + } +} + +// [39] echaracter ::= character | '\t' | '\n' | '\r' +static inline SerdStatus +read_echaracter(SerdReader reader, Ref dest) +{ + uint8_t c = peek_byte(reader); + switch (c) { + case '\\': + eat_byte(reader, '\\'); + if (read_echaracter_escape(reader, peek_byte(reader))) { + return SERD_SUCCESS; + } else { + error(reader, "illegal escape `\\%c'\n", peek_byte(reader)); + return SERD_ERROR; + } + default: + return read_character(reader, dest); + } +} + +// [43] lcharacter ::= echaracter | '\"' | #x9 | #xA | #xD +static inline SerdStatus +read_lcharacter(SerdReader reader, Ref dest) +{ + const uint8_t c = peek_byte(reader); + uint8_t pre[3]; + switch (c) { + case '"': + peek_string(reader, pre, 3); + if (pre[1] == '\"' && pre[2] == '\"') { + eat_byte(reader, '\"'); + eat_byte(reader, '\"'); + eat_byte(reader, '\"'); + return SERD_FAILURE; + } else { + push_byte(reader, dest, eat_byte(reader, '"')); + return SERD_SUCCESS; + } + case '\\': + eat_byte(reader, '\\'); + if (read_scharacter_escape(reader, dest)) { + return SERD_SUCCESS; + } else { + error(reader, "illegal escape `\\%c'\n", peek_byte(reader)); + return SERD_ERROR; + } + case 0x9: case 0xA: case 0xD: + push_byte(reader, dest, eat_byte(reader, c)); + return SERD_SUCCESS; + default: + return read_echaracter(reader, dest); + } +} + +// [42] scharacter ::= ( echaracter - #x22 ) | '\"' +static inline SerdStatus +read_scharacter(SerdReader reader, Ref dest) +{ + uint8_t c = peek_byte(reader); + switch (c) { + case '\\': + eat_byte(reader, '\\'); + if (read_scharacter_escape(reader, dest)) { + return SERD_SUCCESS; + } else { + error(reader, "illegal escape `\\%c'\n", peek_byte(reader)); + return SERD_ERROR; + } + case '\"': + return SERD_FAILURE; + default: + return read_character(reader, dest); + } +} + +// Spec: [41] ucharacter ::= ( character - #x3E ) | '\>' +// Impl: [41] ucharacter ::= ( echaracter - #x3E ) | '\>' +static inline SerdStatus +read_ucharacter(SerdReader reader, Ref dest) +{ + const uint8_t c = peek_byte(reader); + switch (c) { + case '\\': + eat_byte(reader, '\\'); + if (read_ucharacter_escape(reader, dest)) { + return SERD_SUCCESS; + } else { + return error(reader, "illegal escape `\\%c'\n", peek_byte(reader)); + } + case '>': + return SERD_FAILURE; + default: + return read_character(reader, dest); + } +} + +// [10] comment ::= '#' ( [^#xA #xD] )* +static void +read_comment(SerdReader reader) +{ + eat_byte(reader, '#'); + uint8_t 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 reader) +{ + const uint8_t c = peek_byte(reader); + switch (c) { + case 0x9: case 0xA: case 0xD: case 0x20: + eat_byte(reader, c); + return true; + case '#': + read_comment(reader); + return true; + default: + return false; + } +} + +static inline void +read_ws_star(SerdReader reader) +{ + while (read_ws(reader)) {} +} + +static inline bool +read_ws_plus(SerdReader reader) +{ + 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 reader) +{ + eat_string(reader, "\"\"\"", 3); + Ref str = push_string(reader, "", 1); + SerdStatus st; + while (!(st = read_lcharacter(reader, str))) {} + if (st != SERD_ERROR) { + return str; + } + pop_string(reader, str); + return 0; +} + +// [36] string ::= #x22 scharacter* #x22 +static Ref +read_string(SerdReader reader) +{ + eat_byte(reader, '\"'); + Ref str = push_string(reader, "", 1); + SerdStatus st; + while (!(st = read_scharacter(reader, str))) {} + if (st != SERD_ERROR) { + eat_byte(reader, '\"'); + return str; + } + pop_string(reader, str); + return 0; +} + +// [35] quotedString ::= string | longSerdString +static Ref +read_quotedString(SerdReader reader) +{ + uint8_t pre[3]; + peek_string(reader, pre, 3); + assert(pre[0] == '\"'); + switch (pre[1]) { + case '\"': + if (pre[2] == '\"') + return read_longString(reader); + else + return read_string(reader); + default: + return read_string(reader); + } +} + +// [34] relativeURI ::= ucharacter* +static inline Ref +read_relativeURI(SerdReader reader) +{ + Ref str = push_string(reader, "", 1); + SerdStatus st; + while (!(st = read_ucharacter(reader, str))) {} + if (st != SERD_ERROR) { + return str; + } + pop_string(reader, str); + return 0; +} + +// [30] nameStartChar ::= [A-Z] | "_" | [a-z] +// | [#x00C0-#x00D6] | [#x00D8-#x00F6] | [#x00F8-#x02FF] | [#x0370-#x037D] +// | [#x037F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] +// | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF] +static inline uchar +read_nameStartChar(SerdReader reader, bool required) +{ + const uint8_t c = peek_byte(reader); + if (c == '_' || is_alpha(c)) { + return eat_byte(reader, c); + } else { + if (required) { + error(reader, "illegal character `%c'\n", c); + } + return 0; + } +} + +// [31] nameChar ::= nameStartChar | '-' | [0-9] +// | #x00B7 | [#x0300-#x036F] | [#x203F-#x2040] +static inline uchar +read_nameChar(SerdReader reader) +{ + uchar c = read_nameStartChar(reader, false); + if (c) + return c; + + 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(reader, c); + default: + // TODO: 0x300-0x036F | 0x203F-0x2040 + return 0; + } + return 0; +} + +// [33] prefixName ::= ( nameStartChar - '_' ) nameChar* +static Ref +read_prefixName(SerdReader reader) +{ + uint8_t c = peek_byte(reader); + if (c == '_') { + error(reader, "unexpected `_'\n"); + return 0; + } + 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 reader, Ref dest, bool required) +{ + uchar c = read_nameStartChar(reader, required); + if (!c) { + if (required) { + error(reader, "illegal character at start of name\n"); + } + return 0; + } + do { + 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 reader) +{ + const uint8_t start = peek_byte(reader); + if (!in_range(start, 'a', 'z')) { + error(reader, "unexpected `%c'\n", start); + return 0; + } + Ref str = push_string(reader, "", 1); + push_byte(reader, str, eat_byte(reader, start)); + uint8_t c; + while ((c = peek_byte(reader)) && in_range(c, 'a', 'z')) { + push_byte(reader, str, eat_byte(reader, 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; +} + +// [28] uriref ::= '<' relativeURI '>' +static Ref +read_uriref(SerdReader reader) +{ + TRY_RET(eat_byte(reader, '<')); + Ref const str = read_relativeURI(reader); + if (str && eat_byte(reader, '>')) { + return str; + } + pop_string(reader, str); + return 0; +} + +// [27] qname ::= prefixName? ':' name? +static Ref +read_qname(SerdReader reader) +{ + Ref prefix = read_prefixName(reader); + if (!prefix) { + prefix = push_string(reader, "", 1); + } + TRY_THROW(eat_byte(reader, ':')); + push_byte(reader, prefix, ':'); + Ref str = read_name(reader, prefix, false); + return str ? str : prefix; +except: + pop_string(reader, prefix); + return 0; +} + +static bool +read_0_9(SerdReader reader, Ref str, bool at_least_one) +{ + uint8_t c; + if (at_least_one) { + if (!is_digit((c = peek_byte(reader)))) { + return error(reader, "expected digit\n"); + } + push_byte(reader, str, eat_byte(reader, c)); + } + while (is_digit((c = peek_byte(reader)))) { + push_byte(reader, str, eat_byte(reader, c)); + } + return true; +} + +// [19] exponent ::= [eE] ('-' | '+')? [0-9]+ +// [18] decimal ::= ( '-' | '+' )? ( [0-9]+ '.' [0-9]* +// | '.' ([0-9])+ +// | ([0-9])+ ) +// [17] double ::= ( '-' | '+' )? ( [0-9]+ '.' [0-9]* exponent +// | '.' ([0-9])+ exponent +// | ([0-9])+ exponent ) +// [16] integer ::= ( '-' | '+' ) ? [0-9]+ +static bool +read_number(SerdReader reader, Node* dest) +{ + #define XSD_DECIMAL NS_XSD "decimal" + #define XSD_DOUBLE NS_XSD "double" + #define XSD_INTEGER NS_XSD "integer" + Ref str = push_string(reader, "", 1); + uint8_t c = peek_byte(reader); + bool has_decimal = false; + Ref datatype = 0; + if (c == '-' || c == '+') { + push_byte(reader, str, eat_byte(reader, c)); + } + if ((c = peek_byte(reader)) == '.') { + has_decimal = true; + // decimal case 2 (e.g. '.0' or `-.0' or `+.0') + push_byte(reader, str, eat_byte(reader, c)); + TRY_THROW(read_0_9(reader, str, true)); + } else { + // all other cases ::= ( '-' | '+' ) [0-9]+ ( . )? ( [0-9]+ )? ... + TRY_THROW(read_0_9(reader, str, true)); + if ((c = peek_byte(reader)) == '.') { + has_decimal = true; + push_byte(reader, str, eat_byte(reader, c)); + TRY_THROW(read_0_9(reader, str, false)); + } + } + c = peek_byte(reader); + if (c == 'e' || c == 'E') { + // double + push_byte(reader, str, eat_byte(reader, c)); + switch ((c = peek_byte(reader))) { + case '+': case '-': + push_byte(reader, str, eat_byte(reader, c)); + default: break; + } + read_0_9(reader, str, true); + datatype = push_string(reader, XSD_DOUBLE, strlen(XSD_DOUBLE) + 1); + } else if (has_decimal) { + datatype = push_string(reader, XSD_DECIMAL, strlen(XSD_DECIMAL) + 1); + } else { + datatype = push_string(reader, XSD_INTEGER, strlen(XSD_INTEGER) + 1); + } + *dest = make_node(SERD_LITERAL, str, datatype, 0); + assert(dest->value); + return true; +except: + pop_string(reader, datatype); + pop_string(reader, str); + return false; +} + +// [25] resource ::= uriref | qname +static bool +read_resource(SerdReader reader, Node* dest) +{ + switch (peek_byte(reader)) { + case '<': + *dest = make_node(SERD_URI, read_uriref(reader), 0, 0); + break; + default: + *dest = make_node(SERD_CURIE, read_qname(reader), 0, 0); + } + return (dest->value != 0); +} + +// [14] literal ::= quotedString ( '@' language )? | datatypeSerdString +// | integer | double | decimal | boolean +static bool +read_literal(SerdReader reader, Node* dest) +{ + Ref str = 0; + Node datatype = INTERNAL_NODE_NULL; + const uint8_t c = peek_byte(reader); + if (c == '-' || c == '+' || c == '.' || is_digit(c)) { + return read_number(reader, dest); + } else if (c == '\"') { + str = read_quotedString(reader); + if (!str) { + return false; + } + + Ref lang = 0; + switch (peek_byte(reader)) { + case '^': + eat_byte(reader, '^'); + eat_byte(reader, '^'); + TRY_THROW(read_resource(reader, &datatype)); + break; + case '@': + eat_byte(reader, '@'); + TRY_THROW(lang = read_language(reader)); + } + *dest = make_node(SERD_LITERAL, str, datatype.value, lang); + } else { + return error(reader, "Unknown literal type\n"); + } + return true; +except: + pop_string(reader, str); + return false; +} + +// [12] predicate ::= resource +static bool +read_predicate(SerdReader reader, Node* dest) +{ + return read_resource(reader, dest); +} + +// [9] verb ::= predicate | 'a' +static bool +read_verb(SerdReader reader, Node* dest) +{ + uint8_t pre[2]; + peek_string(reader, pre, 2); + switch (pre[0]) { + case 'a': + switch (pre[1]) { + case 0x9: case 0xA: case 0xD: case 0x20: + eat_byte(reader, 'a'); + *dest = make_node(SERD_URI, + push_string(reader, NS_RDF "type", 48), 0, 0); + return true; + default: break; // fall through + } + default: + return read_predicate(reader, dest); + } +} + +// [26] nodeID ::= '_:' name +static Ref +read_nodeID(SerdReader reader) +{ + eat_byte(reader, '_'); + eat_byte(reader, ':'); + Ref str = push_string(reader, "", 1); + return read_name(reader, str, true); +} + +static Ref +blank_id(SerdReader reader) +{ + const char* prefix = reader->blank_prefix + ? (const char*)reader->blank_prefix + : "genid"; + char str[32]; // FIXME: ensure length of reader->blank_prefix is OK + const int len = snprintf(str, sizeof(str), "%s%u", + prefix, reader->next_id++); + return push_string(reader, str, len + 1); +} + +// Spec: [21] blank ::= nodeID | '[]' +// | '[' predicateObjectList ']' | collection +// Impl: [21] blank ::= nodeID | '[ ws* ]' +// | '[' ws* predicateObjectList ws* ']' | collection +static bool +read_blank(SerdReader reader, ReadContext ctx, Node* dest) +{ + switch (peek_byte(reader)) { + case '_': + *dest = make_node(SERD_BLANK_ID, read_nodeID(reader), 0, 0); + return true; + case '[': + eat_byte(reader, '['); + read_ws_star(reader); + if (peek_byte(reader) == ']') { + eat_byte(reader, ']'); + *dest = make_node(SERD_BLANK_ID, blank_id(reader), 0, 0); + if (ctx.subject) { + TRY_RET(emit_statement(reader, ctx.graph, ctx.subject, ctx.predicate, dest)); + } + return true; + } + *dest = make_node(SERD_ANON_BEGIN, blank_id(reader), 0, 0); + if (ctx.subject) { + TRY_RET(emit_statement(reader, ctx.graph, ctx.subject, ctx.predicate, dest)); + dest->type = SERD_ANON; + } + ctx.subject = dest; + read_predicateObjectList(reader, ctx); + read_ws_star(reader); + eat_byte(reader, ']'); + if (reader->end_sink) { + const SerdNode end = public_node(reader, dest); + reader->end_sink(reader->handle, &end); + } + return true; + case '(': + if (read_collection(reader, ctx, dest)) { + if (ctx.subject) { + TRY_RET(emit_statement(reader, ctx.graph, ctx.subject, ctx.predicate, dest)); + } + return true; + } + return false; + default: + return error(reader, "illegal blank node\n"); + } +} + +inline static bool +is_object_end(const uint8_t c) +{ + switch (c) { + case 0x9: case 0xA: case 0xD: case 0x20: case '\0': + case '#': case '.': case ';': + return true; + default: + return false; + } +} + +// [13] object ::= resource | blank | literal +// Recurses, calling statement_sink for every statement encountered. +// Leaves stack in original calling state (i.e. pops everything it pushes). +static bool +read_object(SerdReader reader, ReadContext ctx) +{ + static const char* const XSD_BOOLEAN = NS_XSD "boolean"; + static const size_t XSD_BOOLEAN_LEN = 40; + + uint8_t pre[6]; + bool ret = false; + bool emit = (ctx.subject != 0); + Node o = INTERNAL_NODE_NULL; + const uint8_t c = peek_byte(reader); + switch (c) { + case '\0': + case ')': + return false; + case '[': case '(': + emit = false; + // fall through + case '_': + TRY_THROW(ret = read_blank(reader, ctx, &o)); + break; + case '<': case ':': + 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(reader, &o)); + break; + case '.': + TRY_THROW(ret = read_literal(reader, &o)); + break; + default: + /* Either a boolean literal, or a qname. + Unfortunately there is no way to distinguish these without + readahead, since `true' or `false' could be the start of a qname. + */ + peek_string(reader, pre, 6); + if (!memcmp(pre, "true", 4) && is_object_end(pre[4])) { + 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(SERD_LITERAL, value, datatype, 0); + } else if (!memcmp(pre, "false", 5) && is_object_end(pre[5])) { + 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(SERD_LITERAL, value, datatype, 0); + } else if (!is_object_end(c)) { + o = make_node(SERD_CURIE, read_qname(reader), 0, 0); + } + ret = o.value; + } + + if (ret && emit) { + assert(o.value); + ret = emit_statement(reader, ctx.graph, ctx.subject, ctx.predicate, &o); + } + +except: + pop_string(reader, o.lang); + pop_string(reader, o.datatype); + pop_string(reader, o.value); + return ret; +} + +// Spec: [8] objectList ::= object ( ',' object )* +// Impl: [8] objectList ::= object ( ws* ',' ws* object )* +static bool +read_objectList(SerdReader reader, ReadContext ctx) +{ + TRY_RET(read_object(reader, ctx)); + read_ws_star(reader); + while (peek_byte(reader) == ',') { + eat_byte(reader, ','); + read_ws_star(reader); + TRY_RET(read_object(reader, ctx)); + read_ws_star(reader); + } + return true; +} + +// Spec: [7] predicateObjectList ::= verb objectList +// (';' verb objectList)* (';')? +// Impl: [7] predicateObjectList ::= verb ws+ objectList +// (ws* ';' ws* verb ws+ objectList)* (';')? +static bool +read_predicateObjectList(SerdReader reader, ReadContext ctx) +{ + if (reader->eof) { + return false; + } + Node predicate = INTERNAL_NODE_NULL; + TRY_RET(read_verb(reader, &predicate)); + TRY_THROW(read_ws_plus(reader)); + ctx.predicate = &predicate; + TRY_THROW(read_objectList(reader, ctx)); + pop_string(reader, predicate.value); + predicate.value = 0; + 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(reader, &predicate)); + ctx.predicate = &predicate; + TRY_THROW(read_ws_plus(reader)); + TRY_THROW(read_objectList(reader, ctx)); + pop_string(reader, predicate.value); + predicate.value = 0; + read_ws_star(reader); + } + } + return true; +except: + pop_string(reader, predicate.value); + return false; +} + +/** Recursive helper for read_collection. */ +static bool +read_collection_rec(SerdReader reader, ReadContext ctx) +{ + read_ws_star(reader); + if (peek_byte(reader) == ')') { + eat_byte(reader, ')'); + TRY_RET(emit_statement(reader, NULL, ctx.subject, + &reader->rdf_rest, &reader->rdf_nil)); + return false; + } else { + const Node rest = make_node(SERD_BLANK_ID, blank_id(reader), 0, 0); + TRY_RET(emit_statement(reader, ctx.graph, ctx.subject, &reader->rdf_rest, &rest)); + ctx.subject = &rest; + ctx.predicate = &reader->rdf_first; + if (read_object(reader, ctx)) { + read_collection_rec(reader, ctx); + pop_string(reader, rest.value); + return true; + } else { + pop_string(reader, rest.value); + return false; + } + } +} + +// [22] itemList ::= object+ +// [23] collection ::= '(' itemList? ')' +static bool +read_collection(SerdReader reader, ReadContext ctx, Node* dest) +{ + 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(SERD_BLANK_ID, blank_id(reader), 0, 0); + ctx.subject = dest; + ctx.predicate = &reader->rdf_first; + if (!read_object(reader, ctx)) { + return error(reader, "unexpected end of collection\n"); + } + + ctx.subject = dest; + return read_collection_rec(reader, ctx); +} + +// [11] subject ::= resource | blank +static Node +read_subject(SerdReader reader, ReadContext ctx) +{ + Node subject = INTERNAL_NODE_NULL; + switch (peek_byte(reader)) { + case '[': case '(': case '_': + read_blank(reader, ctx, &subject); + break; + default: + read_resource(reader, &subject); + } + return subject; +} + +// Spec: [6] triples ::= subject predicateObjectList +// Impl: [6] triples ::= subject ws+ predicateObjectList +static bool +read_triples(SerdReader reader, ReadContext ctx) +{ + const Node subject = read_subject(reader, ctx); + bool ret = false; + if (subject.value != 0) { + ctx.subject = &subject; + TRY_RET(read_ws_plus(reader)); + ret = read_predicateObjectList(reader, ctx); + pop_string(reader, subject.value); + } + ctx.subject = ctx.predicate = 0; + return ret; +} + +// [5] base ::= '@base' ws+ uriref +static bool +read_base(SerdReader reader) +{ + // `@' is already eaten in read_directive + eat_string(reader, "base", 4); + TRY_RET(read_ws_plus(reader)); + Ref uri; + TRY_RET(uri = read_uriref(reader)); + const SerdNode uri_node = public_node_from_ref(reader, SERD_URI, uri); + reader->base_sink(reader->handle, &uri_node); + pop_string(reader, uri); + return true; +} + +// Spec: [4] prefixID ::= '@prefix' ws+ prefixName? ':' uriref +// Impl: [4] prefixID ::= '@prefix' ws+ prefixName? ':' ws* uriref +static bool +read_prefixID(SerdReader reader) +{ + // `@' is already eaten in read_directive + eat_string(reader, "prefix", 6); + TRY_RET(read_ws_plus(reader)); + bool ret = false; + Ref name = read_prefixName(reader); + if (!name) { + name = push_string(reader, "", 1); + } + TRY_THROW(eat_byte(reader, ':') == ':'); + read_ws_star(reader); + Ref uri = 0; + TRY_THROW(uri = read_uriref(reader)); + const SerdNode name_node = public_node_from_ref(reader, SERD_LITERAL, name); + const SerdNode uri_node = public_node_from_ref(reader, SERD_URI, uri); + ret = reader->prefix_sink(reader->handle, &name_node, &uri_node); + pop_string(reader, uri); +except: + pop_string(reader, name); + return ret; +} + +// [3] directive ::= prefixID | base +static bool +read_directive(SerdReader reader) +{ + eat_byte(reader, '@'); + switch (peek_byte(reader)) { + case 'b': + return read_base(reader); + case 'p': + return read_prefixID(reader); + default: + return error(reader, "illegal directive\n"); + } +} + +// Spec: [1] statement ::= directive '.' | triples '.' | ws+ +// Impl: [1] statement ::= directive ws* '.' | triples ws* '.' | ws+ +static bool +read_statement(SerdReader reader) +{ + ReadContext ctx = { 0, 0, 0 }; + read_ws_star(reader); + if (reader->eof) { + return true; + } + switch (peek_byte(reader)) { + case '@': + TRY_RET(read_directive(reader)); + break; + default: + TRY_RET(read_triples(reader, ctx)); + break; + } + read_ws_star(reader); + return eat_byte(reader, '.'); +} + +// [1] turtleDoc ::= statement +static bool +read_turtleDoc(SerdReader reader) +{ + while (!reader->eof) { + TRY_RET(read_statement(reader)); + } + return true; +} + +SERD_API +SerdReader +serd_reader_new(SerdSyntax syntax, + void* handle, + SerdBaseSink base_sink, + SerdPrefixSink prefix_sink, + SerdStatementSink statement_sink, + SerdEndSink end_sink) +{ + const Cursor cur = { NULL, 0, 0 }; + SerdReader me = malloc(sizeof(struct SerdReaderImpl)); + me->handle = handle; + me->base_sink = base_sink; + me->prefix_sink = prefix_sink; + me->statement_sink = statement_sink; + me->end_sink = end_sink; + me->fd = 0; + me->stack = serd_stack_new(STACK_PAGE_SIZE); + me->cur = cur; + me->blank_prefix = NULL; + me->next_id = 1; + me->read_buf = 0; + me->read_head = 0; + me->eof = false; +#ifdef SERD_STACK_CHECK + me->alloc_stack = 0; + me->n_allocs = 0; +#endif + +#define RDF_FIRST NS_RDF "first" +#define RDF_REST NS_RDF "rest" +#define RDF_NIL NS_RDF "nil" + me->rdf_first = make_node(SERD_URI, push_string(me, RDF_FIRST, 49), 0, 0); + me->rdf_rest = make_node(SERD_URI, push_string(me, RDF_REST, 48), 0, 0); + me->rdf_nil = make_node(SERD_URI, push_string(me, RDF_NIL, 47), 0, 0); + + return me; +} + +SERD_API +void +serd_reader_free(SerdReader reader) +{ + SerdReader const me = (SerdReader)reader; + pop_string(me, me->rdf_nil.value); + pop_string(me, me->rdf_rest.value); + pop_string(me, me->rdf_first.value); + +#ifdef SERD_STACK_CHECK + free(me->alloc_stack); +#endif + free(me->stack.buf); + free(me); +} + +SERD_API +void +serd_reader_set_blank_prefix(SerdReader reader, + const uint8_t* prefix) +{ + reader->blank_prefix = prefix; +} + +SERD_API +bool +serd_reader_read_file(SerdReader me, FILE* file, const uint8_t* name) +{ + const Cursor cur = { name, 1, 1 }; + me->fd = file; + me->read_buf = (uint8_t*)malloc(READ_BUF_LEN * 2); + me->read_head = 0; + me->cur = cur; + me->from_file = true; + me->eof = false; + + /* Read into the second page of the buffer. Occasionally peek_string + will move the read_head to before this point when readahead causes + a page fault. + */ + memset(me->read_buf, '\0', READ_BUF_LEN * 2); + me->read_buf += READ_BUF_LEN; + + const bool ret = !page(me) || read_turtleDoc(me); + + free(me->read_buf - READ_BUF_LEN); + me->fd = 0; + me->read_buf = NULL; + return ret; +} + +SERD_API +bool +serd_reader_read_string(SerdReader me, const uint8_t* utf8) +{ + const Cursor cur = { (const uint8_t*)"(string)", 1, 1 }; + + me->read_buf = (uint8_t*)utf8; + me->read_head = 0; + me->cur = cur; + me->from_file = false; + + const bool ret = read_turtleDoc(me); + + me->read_buf = NULL; + return ret; +} + +SERD_API +SerdReadState +serd_read_state_new(SerdEnv env, + const uint8_t* base_uri_str) +{ + SerdReadState state = malloc(sizeof(struct SerdReadStateImpl)); + SerdURI base_base_uri = SERD_URI_NULL; + state->env = env; + state->base_uri_node = serd_node_new_uri_from_string( + base_uri_str, &base_base_uri, &state->base_uri); + return state; +} + +SERD_API +void +serd_read_state_free(SerdReadState state) +{ + serd_node_free(&state->base_uri_node); + free(state); +} + +SERD_API +SerdNode +serd_read_state_expand(SerdReadState state, + const SerdNode* node) +{ + if (node->type == SERD_CURIE) { + SerdChunk prefix; + SerdChunk suffix; + serd_env_expand(state->env, node, &prefix, &suffix); + SerdNode ret = { SERD_URI, + prefix.len + suffix.len + 1, + prefix.len + suffix.len, // FIXME: UTF-8 + NULL }; + ret.buf = malloc(ret.n_bytes); + snprintf((char*)ret.buf, ret.n_bytes, "%s%s", prefix.buf, suffix.buf); + return ret; + } else if (node->type == SERD_URI) { + SerdURI ignored; + return serd_node_new_uri_from_node(node, &state->base_uri, &ignored); + } else { + return SERD_NODE_NULL; + } +} + +SERD_API +SerdNode +serd_read_state_get_base_uri(SerdReadState state, + SerdURI* out) +{ + *out = state->base_uri; + return state->base_uri_node; +} + +SERD_API +bool +serd_read_state_set_base_uri(SerdReadState state, + const SerdNode* uri_node) +{ + // Resolve base URI and create a new node and URI for it + SerdURI base_uri; + SerdNode base_uri_node = serd_node_new_uri_from_node( + uri_node, &state->base_uri, &base_uri); + + if (base_uri_node.buf) { + // Replace the current base URI + serd_node_free(&state->base_uri_node); + state->base_uri_node = base_uri_node; + state->base_uri = base_uri; + return true; + } + return false; +} + +SERD_API +bool +serd_read_state_set_prefix(SerdReadState state, + const SerdNode* name, + const SerdNode* uri_node) +{ + if (serd_uri_string_has_scheme(uri_node->buf)) { + // Set prefix to absolute URI + serd_env_add(state->env, name, uri_node); + return true; + } else { + // Resolve relative URI and create a new node and URI for it + SerdURI abs_uri; + SerdNode abs_uri_node = serd_node_new_uri_from_node( + uri_node, &state->base_uri, &abs_uri); + + if (!abs_uri_node.buf) { + return false; + } + + // Set prefix to resolved (absolute) URI + serd_env_add(state->env, name, &abs_uri_node); + serd_node_free(&abs_uri_node); + return true; + } + return false; +} + + +/** + * @file uri.c + */ + +/** @file uri.c */ + +#include <assert.h> +#include <stdlib.h> +#include <string.h> + + +// #define URI_DEBUG 1 + +SERD_API +bool +serd_uri_string_has_scheme(const uint8_t* utf8) +{ + // RFC3986: scheme ::= ALPHA *( ALPHA / DIGIT / "+" / "-" / "." ) + if (!is_alpha(utf8[0])) { + return false; // Invalid scheme initial character, URI is relative + } + for (uint8_t c = *++utf8; (c = *utf8) != '\0'; ++utf8) { + switch (c) { + case ':': + return true; // End of scheme + case '+': case '-': case '.': + break; // Valid scheme character, continue + default: + if (!is_alpha(c) && !is_digit(c)) { + return false; // Invalid scheme character + } + } + } + + return false; +} + +#ifdef URI_DEBUG +static void +serd_uri_dump(const SerdURI* uri, FILE* file) +{ +#define PRINT_PART(range, name) \ + if (range.buf) { \ + fprintf(stderr, " " name " = "); \ + fwrite((range).buf, 1, (range).len, stderr); \ + fprintf(stderr, "\n"); \ + } + + PRINT_PART(uri->scheme, "scheme"); + PRINT_PART(uri->authority, "authority"); + PRINT_PART(uri->path_base, "path_base"); + PRINT_PART(uri->path, "path"); + PRINT_PART(uri->query, "query"); + PRINT_PART(uri->fragment, "fragment"); +} +#endif + +SERD_API +bool +serd_uri_parse(const uint8_t* utf8, SerdURI* uri) +{ + *uri = SERD_URI_NULL; + assert(uri->path_base.buf == NULL); + assert(uri->path_base.len == 0); + assert(uri->authority.len == 0); + + const uint8_t* ptr = utf8; + + /* See http://tools.ietf.org/html/rfc3986#section-3 + URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ] + */ + + /* S3.1: scheme ::= ALPHA *( ALPHA / DIGIT / "+" / "-" / "." ) */ + if (is_alpha(*ptr)) { + for (uint8_t c = *++ptr; true; c = *++ptr) { + switch (c) { + case '\0': case '/': case '?': case '#': + ptr = utf8; + goto path; // Relative URI (starts with path by definition) + case ':': + uri->scheme.buf = utf8; + uri->scheme.len = (ptr++) - utf8; + goto maybe_authority; // URI with scheme + case '+': case '-': case '.': + continue; + default: + if (is_alpha(c) || is_digit(c)) { + continue; + } + } + } + } + + /* S3.2: The authority component is preceded by a double slash ("//") + and is terminated by the next slash ("/"), question mark ("?"), + or number sign ("#") character, or by the end of the URI. + */ +maybe_authority: + if (*ptr == '/' && *(ptr + 1) == '/') { + ptr += 2; + uri->authority.buf = ptr; + assert(uri->authority.len == 0); + for (uint8_t c = *ptr; (c = *ptr) != '\0'; ++ptr) { + switch (c) { + case '/': goto path; + case '?': goto query; + case '#': goto fragment; + default: + ++uri->authority.len; + } + } + } + + /* RFC3986 S3.3: The path is terminated by the first question mark ("?") + or number sign ("#") character, or by the end of the URI. + */ +path: + switch (*ptr) { + case '?': goto query; + case '#': goto fragment; + case '\0': goto end; + default: break; + } + uri->path.buf = ptr; + uri->path.len = 0; + for (uint8_t c = *ptr; (c = *ptr) != '\0'; ++ptr) { + switch (c) { + case '?': goto query; + case '#': goto fragment; + default: + ++uri->path.len; + } + } + + /* RFC3986 S3.4: The query component is indicated by the first question + mark ("?") character and terminated by a number sign ("#") character + or by the end of the URI. + */ +query: + if (*ptr == '?') { + uri->query.buf = ++ptr; + for (uint8_t c = *ptr; (c = *ptr) != '\0'; ++ptr) { + switch (c) { + case '#': + goto fragment; + default: + ++uri->query.len; + } + } + } + + /* RFC3986 S3.5: A fragment identifier component is indicated by the + presence of a number sign ("#") character and terminated by the end + of the URI. + */ +fragment: + if (*ptr == '#') { + uri->fragment.buf = ptr; + while (*ptr++ != '\0') { + ++uri->fragment.len; + } + } + +end: + #ifdef URI_DEBUG + fprintf(stderr, "PARSE URI <%s>\n", utf8); + serd_uri_dump(uri, stderr); + fprintf(stderr, "\n"); + #endif + + return true; +} + +SERD_API +void +serd_uri_resolve(const SerdURI* r, const SerdURI* base, SerdURI* t) +{ + // See http://tools.ietf.org/html/rfc3986#section-5.2.2 + + t->path_base.buf = NULL; + t->path_base.len = 0; + if (r->scheme.len) { + *t = *r; + } else { + if (r->authority.len) { + t->authority = r->authority; + t->path = r->path; + t->query = r->query; + } else { + t->path = r->path; + if (!r->path.len) { + t->path_base = base->path; + if (r->query.len) { + t->query = r->query; + } else { + t->query = base->query; + } + } else { + if (r->path.buf[0] != '/') { + t->path_base = base->path; + } + t->query = r->query; + } + t->authority = base->authority; + } + t->scheme = base->scheme; + t->fragment = r->fragment; + } + + #ifdef URI_DEBUG + fprintf(stderr, "RESOLVE URI\nBASE:\n"); + serd_uri_dump(base, stderr); + fprintf(stderr, "URI:\n"); + serd_uri_dump(r, stderr); + fprintf(stderr, "RESULT:\n"); + serd_uri_dump(t, stderr); + fprintf(stderr, "\n"); + #endif +} + +SERD_API +size_t +serd_uri_serialise(const SerdURI* uri, SerdSink sink, void* stream) +{ + // See http://tools.ietf.org/html/rfc3986#section-5.3 + + size_t write_size = 0; +#define WRITE(buf, len) \ + write_size += len; \ + if (len) { \ + sink((const uint8_t*)buf, len, stream); \ + } +#define WRITE_CHAR(c) WRITE(&(c), 1) +#define WRITE_COMPONENT(prefix, field, suffix) \ + if ((field).len) { \ + for (const uint8_t* c = (const uint8_t*)prefix; *c != '\0'; ++c) { \ + WRITE(c, 1); \ + } \ + WRITE((field).buf, (field).len); \ + for (const uint8_t* c = (const uint8_t*)suffix; *c != '\0'; ++c) { \ + WRITE(c, 1); \ + } \ + } + + WRITE_COMPONENT("", uri->scheme, ":"); + if (uri->authority.buf) { + WRITE("//", 2); + WRITE(uri->authority.buf, uri->authority.len); + } + if (uri->path_base.len) { + if (!uri->path.buf && (uri->fragment.buf || uri->query.buf)) { + WRITE_COMPONENT("", uri->path_base, ""); + } else { + /* Merge paths, removing dot components. + See http://tools.ietf.org/html/rfc3986#section-5.2.3 + */ + const uint8_t* begin = uri->path.buf; + const uint8_t* end = begin; + size_t up = 1; + if (begin) { + // Count and skip leading dot components + end = uri->path.buf + uri->path.len; + for (bool done = false; !done && (begin < end);) { + switch (begin[0]) { + case '.': + switch (begin[1]) { + case '/': + begin += 2; // Chop leading "./" + break; + case '.': + ++up; + switch (begin[2]) { + case '/': + begin += 3; // Chop lading "../" + break; + default: + begin += 2; // Chop leading ".." + } + break; + default: + ++begin; // Chop leading "." + } + break; + case '/': + if (begin[1] == '/') { + ++begin; // Replace leading "//" with "/" + break; + } // else fall through + default: + done = true; // Finished chopping dot components + } + } + + if (uri->path.buf && uri->path_base.buf) { + // Find the up'th last slash + const uint8_t* base_last = uri->path_base.buf + uri->path_base.len - 1; + do { + if (*base_last == '/') { + --up; + } + } while (up > 0 && (--base_last > uri->path_base.buf)); + + // Write base URI prefix + const size_t base_len = base_last - uri->path_base.buf + 1; + WRITE(uri->path_base.buf, base_len); + + } else { + // Relative path is just query or fragment, append it to full base URI + WRITE_COMPONENT("", uri->path_base, ""); + } + + // Write URI suffix + WRITE(begin, end - begin); + } + } + } else { + WRITE_COMPONENT("", uri->path, ""); + } + WRITE_COMPONENT("?", uri->query, ""); + if (uri->fragment.buf) { + // Note uri->fragment.buf includes the leading `#' + WRITE_COMPONENT("", uri->fragment, ""); + } + return write_size; +} + +/** + * @file writer.c + */ + +#include <assert.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + + +#define NS_RDF "http://www.w3.org/1999/02/22-rdf-syntax-ns#" +#define NS_XSD "http://www.w3.org/2001/XMLSchema#" + +typedef struct { + SerdNode graph; + SerdNode subject; + SerdNode predicate; +} WriteContext; + +static const WriteContext WRITE_CONTEXT_NULL = { + { 0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0} +}; + +struct SerdWriterImpl { + SerdSyntax syntax; + SerdStyle style; + SerdEnv env; + SerdURI base_uri; + SerdStack anon_stack; + SerdSink sink; + void* stream; + WriteContext context; + unsigned indent; +}; + +typedef enum { + WRITE_NORMAL, + WRITE_URI, + WRITE_STRING +} TextContext; + +static inline WriteContext* +anon_stack_top(SerdWriter writer) +{ + assert(!serd_stack_is_empty(&writer->anon_stack)); + return (WriteContext*)(writer->anon_stack.buf + + writer->anon_stack.size - sizeof(WriteContext)); +} + +static bool +write_text(SerdWriter writer, TextContext ctx, + const uint8_t* utf8, size_t n_bytes, uint8_t terminator) +{ + char escape[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + for (size_t i = 0; i < n_bytes;) { + uint8_t in = utf8[i++]; + switch (in) { + case '\\': writer->sink("\\\\", 2, writer->stream); continue; + case '\n': writer->sink("\\n", 2, writer->stream); continue; + case '\r': writer->sink("\\r", 2, writer->stream); continue; + case '\t': writer->sink("\\t", 2, writer->stream); continue; + case '"': + if (terminator == '"') { + writer->sink("\\\"", 2, writer->stream); + continue; + } // else fall-through + default: break; + } + + if (in == terminator) { + snprintf(escape, 7, "\\u%04X", terminator); + writer->sink(escape, 6, writer->stream); + continue; + } + + uint32_t c = 0; + size_t size = 0; + if ((in & 0x80) == 0) { // Starts with `0' + size = 1; + c = in & 0x7F; + if (in_range(in, 0x20, 0x7E)) { // Printable ASCII + writer->sink(&in, 1, writer->stream); + continue; + } + } else if ((in & 0xE0) == 0xC0) { // Starts with `110' + size = 2; + c = in & 0x1F; + } else if ((in & 0xF0) == 0xE0) { // Starts with `1110' + size = 3; + c = in & 0x0F; + } else if ((in & 0xF8) == 0xF0) { // Starts with `11110' + size = 4; + c = in & 0x07; + } else { + fprintf(stderr, "invalid UTF-8 at offset %zu: %X\n", i, in); + return false; + } + + if (ctx == WRITE_STRING && !(writer->style & SERD_STYLE_ASCII)) { + // Write UTF-8 character directly to UTF-8 output + // TODO: Scan to next escape and write entire range at once + writer->sink(utf8 + i - 1, size, writer->stream); + i += size - 1; + continue; + } + +#define READ_BYTE() do { \ + assert(i < n_bytes); \ + in = utf8[i++] & 0x3f; \ + c <<= 6; \ + c |= in; \ + } while (0) + + switch (size) { + case 4: READ_BYTE(); + case 3: READ_BYTE(); + case 2: READ_BYTE(); + } + + if (c < 0xFFFF) { + snprintf(escape, 7, "\\u%04X", c); + writer->sink(escape, 6, writer->stream); + } else { + snprintf(escape, 11, "\\U%08X", c); + writer->sink(escape, 10, writer->stream); + } + } + return true; +} + +static void +serd_writer_write_delim(SerdWriter writer, const uint8_t delim) +{ + switch (delim) { + case '\n': + break; + default: + writer->sink(" ", 1, writer->stream); + case '[': + writer->sink(&delim, 1, writer->stream); + } + writer->sink("\n", 1, writer->stream); + for (unsigned i = 0; i < writer->indent; ++i) { + writer->sink("\t", 1, writer->stream); + } +} + +static bool +write_node(SerdWriter writer, + const SerdNode* node, + const SerdNode* datatype, + const SerdNode* lang) +{ + SerdChunk uri_prefix; + SerdChunk uri_suffix; + switch (node->type) { + case SERD_NOTHING: + return false; + case SERD_ANON_BEGIN: + if (writer->syntax != SERD_NTRIPLES) { + ++writer->indent; + serd_writer_write_delim(writer, '['); + WriteContext* ctx = (WriteContext*)serd_stack_push( + &writer->anon_stack, sizeof(WriteContext)); + *ctx = writer->context; + writer->context.subject = *node; + writer->context.predicate = SERD_NODE_NULL; + break; + } + case SERD_ANON: + if (writer->syntax != SERD_NTRIPLES) { + break; + } // else fall through + case SERD_BLANK_ID: + writer->sink("_:", 2, writer->stream); + writer->sink(node->buf, node->n_bytes - 1, writer->stream); + break; + case SERD_CURIE: + switch (writer->syntax) { + case SERD_NTRIPLES: + if (!serd_env_expand(writer->env, node, &uri_prefix, &uri_suffix)) { + fprintf(stderr, "error: undefined namespace prefix `%s'\n", node->buf); + return false; + } + writer->sink("<", 1, writer->stream); + write_text(writer, WRITE_URI, uri_prefix.buf, uri_prefix.len, '>'); + write_text(writer, WRITE_URI, uri_suffix.buf, uri_suffix.len, '>'); + writer->sink(">", 1, writer->stream); + break; + case SERD_TURTLE: + writer->sink(node->buf, node->n_bytes - 1, writer->stream); + } + break; + case SERD_LITERAL: + if (writer->syntax == SERD_TURTLE && datatype && datatype->buf) { + // TODO: compare against NS_XSD prefix once + if (!strcmp((const char*)datatype->buf, NS_XSD "boolean") + || !strcmp((const char*)datatype->buf, NS_XSD "decimal") + || !strcmp((const char*)datatype->buf, NS_XSD "integer")) { + writer->sink(node->buf, node->n_bytes - 1, writer->stream); + break; + } + } + writer->sink("\"", 1, writer->stream); + write_text(writer, WRITE_STRING, node->buf, node->n_bytes - 1, '"'); + writer->sink("\"", 1, writer->stream); + if (lang && lang->buf) { + writer->sink("@", 1, writer->stream); + writer->sink(lang->buf, lang->n_bytes - 1, writer->stream); + } else if (datatype && datatype->buf) { + writer->sink("^^", 2, writer->stream); + write_node(writer, datatype, NULL, NULL); + } + break; + case SERD_URI: + if ((writer->syntax == SERD_TURTLE) + && !strcmp((const char*)node->buf, NS_RDF "type")) { + writer->sink("a", 1, writer->stream); + return true; + } else if ((writer->style & SERD_STYLE_CURIED) + && serd_uri_string_has_scheme(node->buf)) { + SerdNode prefix; + SerdChunk suffix; + if (serd_env_qualify(writer->env, node, &prefix, &suffix)) { + write_text(writer, WRITE_URI, prefix.buf, prefix.n_bytes - 1, '>'); + writer->sink(":", 1, writer->stream); + write_text(writer, WRITE_URI, suffix.buf, suffix.len, '>'); + return true; + } + } else if ((writer->style & SERD_STYLE_RESOLVED) + && !serd_uri_string_has_scheme(node->buf)) { + SerdURI uri; + if (serd_uri_parse(node->buf, &uri)) { + SerdURI abs_uri; + serd_uri_resolve(&uri, &writer->base_uri, &abs_uri); + writer->sink("<", 1, writer->stream); + serd_uri_serialise(&abs_uri, writer->sink, writer->stream); + writer->sink(">", 1, writer->stream); + return true; + } + } + writer->sink("<", 1, writer->stream); + write_text(writer, WRITE_URI, node->buf, node->n_bytes - 1, '>'); + writer->sink(">", 1, writer->stream); + return true; + } + return true; +} + +SERD_API +bool +serd_writer_write_statement(SerdWriter writer, + const SerdNode* graph, + const SerdNode* subject, + const SerdNode* predicate, + const SerdNode* object, + const SerdNode* object_datatype, + const SerdNode* object_lang) +{ + assert(subject && predicate && object); + switch (writer->syntax) { + case SERD_NTRIPLES: + write_node(writer, subject, NULL, NULL); + writer->sink(" ", 1, writer->stream); + write_node(writer, predicate, NULL, NULL); + writer->sink(" ", 1, writer->stream); + if (!write_node(writer, object, object_datatype, object_lang)) { + return false; + } + writer->sink(" .\n", 3, writer->stream); + return true; + case SERD_TURTLE: + break; + } + if (subject->buf == writer->context.subject.buf) { + if (predicate->buf == writer->context.predicate.buf) { // Abbreviate S P + ++writer->indent; + serd_writer_write_delim(writer, ','); + write_node(writer, object, object_datatype, object_lang); + --writer->indent; + } else { // Abbreviate S + if (writer->context.predicate.buf) { + serd_writer_write_delim(writer, ';'); + } else { + ++writer->indent; + serd_writer_write_delim(writer, '\n'); + } + write_node(writer, predicate, NULL, NULL); + writer->context.predicate = *predicate; + writer->sink(" ", 1, writer->stream); + write_node(writer, object, object_datatype, object_lang); + } + } else { + if (writer->context.subject.buf) { + if (writer->indent > 0) { + --writer->indent; + } + if (serd_stack_is_empty(&writer->anon_stack)) { + serd_writer_write_delim(writer, '.'); + serd_writer_write_delim(writer, '\n'); + } + } + + if (subject->type == SERD_ANON_BEGIN) { + writer->sink("[ ", 2, writer->stream); + ++writer->indent; + WriteContext* ctx = (WriteContext*)serd_stack_push( + &writer->anon_stack, sizeof(WriteContext)); + *ctx = writer->context; + } else { + write_node(writer, subject, NULL, NULL); + ++writer->indent; + if (subject->type != SERD_ANON_BEGIN && subject->type != SERD_ANON) { + serd_writer_write_delim(writer, '\n'); + } + } + + writer->context.subject = *subject; + writer->context.predicate = SERD_NODE_NULL; + + write_node(writer, predicate, NULL, NULL); + writer->context.predicate = *predicate; + writer->sink(" ", 1, writer->stream); + + write_node(writer, object, object_datatype, object_lang); + } + + const WriteContext new_context = { graph ? *graph : SERD_NODE_NULL, + *subject, + *predicate }; + writer->context = new_context; + return true; +} + +SERD_API +bool +serd_writer_end_anon(SerdWriter writer, + const SerdNode* node) +{ + if (writer->syntax == SERD_NTRIPLES) { + return true; + } + if (serd_stack_is_empty(&writer->anon_stack)) { + fprintf(stderr, "unexpected end of anonymous node\n"); + return false; + } + assert(writer->indent > 0); + --writer->indent; + serd_writer_write_delim(writer, '\n'); + writer->sink("]", 1, writer->stream); + writer->context = *anon_stack_top(writer); + serd_stack_pop(&writer->anon_stack, sizeof(WriteContext)); + if (!writer->context.subject.buf) { // End of anonymous subject + writer->context.subject = *node; + } + return true; +} + +SERD_API +void +serd_writer_finish(SerdWriter writer) +{ + if (writer->context.subject.buf) { + writer->sink(" .\n", 3, writer->stream); + writer->context.subject.buf = NULL; + } +} + +SERD_API +SerdWriter +serd_writer_new(SerdSyntax syntax, + SerdStyle style, + SerdEnv env, + const SerdURI* base_uri, + SerdSink sink, + void* stream) +{ + const WriteContext context = WRITE_CONTEXT_NULL; + SerdWriter writer = malloc(sizeof(struct SerdWriterImpl)); + writer->syntax = syntax; + writer->style = style; + writer->env = env; + writer->base_uri = base_uri ? *base_uri : SERD_URI_NULL; + writer->anon_stack = serd_stack_new(sizeof(WriteContext)); + writer->sink = sink; + writer->stream = stream; + writer->context = context; + writer->indent = 0; + return writer; +} + +SERD_API +void +serd_writer_set_base_uri(SerdWriter writer, + const SerdURI* uri) +{ + writer->base_uri = *uri; + if (writer->syntax != SERD_NTRIPLES) { + if (writer->context.graph.buf || writer->context.subject.buf) { + writer->sink(" .\n\n", 4, writer->stream); + writer->context = WRITE_CONTEXT_NULL; + } + writer->sink("@base <", 7, writer->stream); + serd_uri_serialise(uri, writer->sink, writer->stream); + writer->sink("> .\n", 4, writer->stream); + } + writer->context = WRITE_CONTEXT_NULL; +} + +SERD_API +bool +serd_writer_set_prefix(SerdWriter writer, + const SerdNode* name, + const SerdNode* uri) +{ + if (writer->syntax != SERD_NTRIPLES) { + if (writer->context.graph.buf || writer->context.subject.buf) { + writer->sink(" .\n\n", 4, writer->stream); + writer->context = WRITE_CONTEXT_NULL; + } + writer->sink("@prefix ", 8, writer->stream); + writer->sink(name->buf, name->n_bytes - 1, writer->stream); + writer->sink(": <", 3, writer->stream); + write_text(writer, WRITE_URI, uri->buf, uri->n_bytes - 1, '>'); + writer->sink("> .\n", 4, writer->stream); + } + writer->context = WRITE_CONTEXT_NULL; + return true; +} + +SERD_API +void +serd_writer_free(SerdWriter writer) +{ + SerdWriter const me = (SerdWriter)writer; + serd_writer_finish(me); + serd_stack_free(&writer->anon_stack); + free(me); +} |