diff options
Diffstat (limited to 'core.lv2')
| -rwxr-xr-x | core.lv2/lv2config | 180 | ||||
| -rw-r--r-- | core.lv2/lv2config.c | 379 | ||||
| l--------- | core.lv2/lv2config.py | 1 | ||||
| -rw-r--r-- | core.lv2/serd-0.1.0.c | 2700 | ||||
| -rw-r--r-- | core.lv2/serd-0.1.0.h | 634 | ||||
| -rw-r--r-- | core.lv2/wscript | 51 |
6 files changed, 3758 insertions, 187 deletions
diff --git a/core.lv2/lv2config b/core.lv2/lv2config deleted file mode 100755 index 590656c..0000000 --- a/core.lv2/lv2config +++ /dev/null @@ -1,180 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- - -"""A program (and Python module) to generate a tree of symlinks to LV2 -extension bundles, where the path of the symlink corresponds to the URI of -the extension. This allows including extension headers in code without using -the bundle name. Including extension headers in this way is much better, -since there is no dependency on the (meaningless and non-persistent) bundle -name in the code using the header. - -For example, after running lv2config (and setting the compiler include -path appropriately), LV2 headers could be included like so: - -#include "lv2/lv2plug.in/ns/lv2core/lv2.h" -#include "lv2/lv2plug.in/ns/ext/event/event.h" -#include "lv2/example.org/foo/foo.h" - -Where the initial "lv2" is arbitrary; in this case lv2config's output -directory was "lv2", and that directory's parent was added to the compiler -include search path. It is a good idea to use such a prefix directory so -domain names do not conflict with anything else in the include path. -""" - -from __future__ import print_function - -__authors__ = 'David Robillard' -__license = 'GNU GPL v3 or later <http://www.gnu.org/licenses/gpl.html>' -__contact__ = 'devel@lists.lv2plug.in' -__date__ = '2010-10-05' - -import errno -import glob -import os -import stat -import sys - -redland = True - -try: - import RDF # Attempt to import Redland -except: - try: - import rdflib # Attempt to import RDFLib - redland = False - except: - print("""Failed to import `RDF' (Redland) or `rdflib'. -(Please install either package, likely `python-librdf' or `python-rdflib')""",file=sys.stderr) - sys.exit(1) - -def rdf_namespace(uri): - "Create a new RDF namespace" - if redland: - return RDF.NS(uri) - else: - return rdflib.Namespace(uri) - -def rdf_load(uri): - "Load an RDF model" - if redland: - model = RDF.Model() - parser = RDF.Parser(name="turtle") - parser.parse_into_model(model, uri) - else: - model = rdflib.ConjunctiveGraph() - model.parse(uri, format="n3") - return model - -def rdf_find_type(model, rdf_type): - "Return a list of the URIs of all resources in model with a given type" - if redland: - results = model.find_statements(RDF.Statement(None, rdf.type, rdf_type)) - ret = [] - for r in results: - ret.append(str(r.subject.uri)) - return ret - else: - results = model.triples([None, rdf.type, rdf_type]) - ret = [] - for r in results: - ret.append(r[0]) - return ret - -rdf = rdf_namespace('http://www.w3.org/1999/02/22-rdf-syntax-ns#') -lv2 = rdf_namespace('http://lv2plug.in/ns/lv2core#') - -def lv2_path(): - "Return the LV2 search path (LV2_PATH in the environment, or a default)." - if 'LV2_PATH' in os.environ: - return os.environ['LV2_PATH'] - else: - ret = '/usr/lib/lv2' + os.pathsep + '/usr/local/lib/lv2' - print('LV2_PATH unset, using default', ret) - return ret - -def __mkdir_p(path): - "Equivalent of UNIX mkdir -p" - try: - os.makedirs(path) - except OSError, e: - if e.errno == errno.EEXIST: - pass - else: - raise - -def build_tree(search_path, outdir): - """Build a directory tree under outdir containing symlinks to all LV2 - extensions found in search_path, such that the symlink paths correspond to - the extension URIs.""" - if os.path.basename(outdir) != 'lv2': - print >> sys.stderr, "lv2config: output dir must be named `lv2'" - sys.exit(1) - - if os.access(outdir, os.F_OK) and not os.access(outdir, os.W_OK): - print ("lv2config: cannot build `%s': Permission denied" % outdir, file=sys.stderr) - sys.exit(1) - - for dir in search_path.split(os.pathsep): - if not os.access(dir, os.F_OK): - continue - - print('Building includes in %s for %s/*.lv2' % (outdir, dir)) - for bundle in glob.glob(os.path.join(dir, '*.lv2')): - # Load manifest into model - manifest = rdf_load('file://' + os.path.join(bundle, 'manifest.ttl')) - - # Query extension URI - specs = rdf_find_type(manifest, lv2.Specification) - for ext_uri in specs: - ext_path = os.path.normpath(ext_uri[ext_uri.find(':') + 1:].lstrip('/')) - ext_dir = os.path.join(outdir, ext_path) - - # Make parent directories - __mkdir_p(os.path.dirname(ext_dir)) - - # Remove existing symlink if necessary - if os.access(ext_dir, os.F_OK): - mode = os.lstat(ext_dir)[stat.ST_MODE] - if stat.S_ISLNK(mode): - os.remove(ext_dir) - else: - raise Exception(ext_dir + " exists and is not a link") - - # Make symlink to bundle directory - os.symlink(bundle, ext_dir) - -def __usage(): - script = os.path.basename(sys.argv[0]) - print("""Usage: %(script)s - Build the default system lv2 include directories, - /usr/include/lv2 and /usr/local/include/lv2 - -Usage: %(script)s INCLUDEDIR - Build an lv2 include directory tree at INCLUDEDIR - for all extensions found in $LV2_PATH. - -Usage: %(script)s BUNDLESDIR INCLUDEDIR - Build an lv2 include directory tree at INCLUDEDIR - for all extensions found in bundles under BUNDLESDIR. -""" % {'script' : script}) - -if __name__ == "__main__": - args = sys.argv[1:] - - if len(args) == 0: - build_tree('/usr/local/lib/lv2', '/usr/local/include/lv2') - build_tree('/usr/lib/lv2', '/usr/include/lv2') - build_tree('/Library/Audio/Plug-Ins/LV2', '/Developer/Headers/lv2') - - elif '--help' in args or '-h' in args: - __usage() - - elif len(args) == 1: - build_tree(lv2_path(), args[0]) - - elif len(args) == 2: - build_tree(args[0], args[1]) - - else: - __usage() - sys.exit(1) diff --git a/core.lv2/lv2config.c b/core.lv2/lv2config.c new file mode 100644 index 0000000..7674c14 --- /dev/null +++ b/core.lv2/lv2config.c @@ -0,0 +1,379 @@ +/* + 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. +*/ + +#define _XOPEN_SOURCE 500 + +#include <errno.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include <dirent.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <unistd.h> +#include <wordexp.h> + +#include "serd-0.1.0.h" + +#include "lv2-config.h" + +#define NS_RDF "http://www.w3.org/1999/02/22-rdf-syntax-ns#" +#define NS_LV2 "http://lv2plug.in/ns/lv2core#" + +typedef struct _Spec { + SerdNode uri; + SerdNode manifest; +} Spec; + +typedef struct { + SerdReader reader; + SerdReadState state; + const uint8_t* current_file; + Spec* specs; + size_t n_specs; +} World; + +/* Append a discovered specification to world->specs. */ +void +add_spec(World* world, + SerdNode* uri, + const uint8_t* manifest) +{ + world->specs = realloc(world->specs, sizeof(Spec) * (world->n_specs + 1)); + world->specs[world->n_specs].uri = *uri; + world->specs[world->n_specs].manifest = serd_node_from_string( + SERD_URI, (const uint8_t*)strdup((const char*)manifest)); + ++world->n_specs; +} + +/** Free world->specs. */ +void +free_specs(World* world) +{ + for (size_t i = 0; i < world->n_specs; ++i) { + Spec* spec = &world->specs[i]; + serd_node_free(&spec->uri); + serd_node_free(&spec->manifest); + } + free(world->specs); + world->specs = NULL; + world->n_specs = 0; +} + +/** Reader @base directive handler. */ +bool +on_base(void* handle, + const SerdNode* uri_node) +{ + World* const world = (World*)handle; + return serd_read_state_set_base_uri(world->state, uri_node); +} + +/** Reader @prefix directive handler. */ +static bool +on_prefix(void* handle, + const SerdNode* name, + const SerdNode* uri_node) +{ + World* const world = (World*)handle; + return serd_read_state_set_prefix(world->state, name, uri_node); +} + +/** Reader statement handler. */ +static bool +on_statement(void* handle, + const SerdNode* graph, + const SerdNode* subject, + const SerdNode* predicate, + const SerdNode* object, + const SerdNode* object_datatype, + const SerdNode* object_lang) +{ + World* world = (World*)handle; + SerdReadState state = world->state; + SerdNode abs_s = serd_read_state_expand(state, subject); + SerdNode abs_p = serd_read_state_expand(state, predicate); + SerdNode abs_o = serd_read_state_expand(state, object); + + if (abs_s.buf && abs_p.buf && abs_o.buf + && !strcmp((const char*)abs_p.buf, NS_RDF "type") + && !strcmp((const char*)abs_o.buf, NS_LV2 "Specification")) { + add_spec(world, &abs_s, world->current_file); + } else { + serd_node_free(&abs_s); + } + serd_node_free(&abs_p); + serd_node_free(&abs_o); + return true; +} + +/** Add any specifications found in a manifest.ttl to world->specs. */ +static void +scan_manifest(World* world, const char* uri) +{ + SerdEnv env = serd_env_new(); + + world->state = serd_read_state_new(env, (const uint8_t*)uri); + + const char* const path = uri + strlen("file://"); + FILE* fd = fopen(path, "r"); + if (fd) { + world->current_file = (const uint8_t*)uri; + if (!serd_reader_read_file(world->reader, fd, (const uint8_t*)uri)) { + fprintf(stderr, "lv2config: error reading <%s>\n", path); + } + world->current_file = NULL; + fclose(fd); + } else { + fprintf(stderr, "lv2config: failed to open <%s>\n", path); + } + + serd_read_state_free(world->state); + serd_env_free(env); + world->state = NULL; +} + +/** Expand variables, ~, etc. in path. */ +static char* +expand(const char* path) +{ + char* ret = NULL; + wordexp_t p; + + wordexp(path, &p, 0); + if (p.we_wordc == 0) { + /* Literal directory path (e.g. no variables or ~) */ + ret = strdup(path); + } else if (p.we_wordc == 1) { + /* Directory path expands (e.g. contains ~ or $FOO) */ + ret = strdup(p.we_wordv[0]); + } else { + /* Multiple expansions in a single directory path? */ + fprintf(stderr, "lv2config: malformed path `%s' ignored\n", path); + } + + wordfree(&p); + return ret; +} + +/** Scan all bundles in path (i.e. scan all path/foo.lv2/manifest.ttl). */ +void +scan_dir(World* world, const char* path) +{ + char* full_path = expand(path); + if (!full_path) { + return; + } + + DIR* dir = opendir(full_path); + if (!dir) { + free(full_path); + return; + } + + struct dirent* file; + while ((file = readdir(dir))) { + if (!strcmp(file->d_name, ".") || !strcmp(file->d_name, "..")) { + continue; + } + + char* uri = malloc(strlen("file://") + + strlen(full_path) + 1 + + strlen(file->d_name) + 1 + + strlen("manifest.ttl") + 1); + + sprintf(uri, "file://%s/%s/manifest.ttl", + full_path, file->d_name); + + scan_manifest(world, uri); + free(uri); + } + + closedir(dir); + free(full_path); +} + +/** Create all parent directories of dir_path, but not dir_path itself. */ +int +mkdir_parents(const char* dir_path) +{ + char* path = strdup(dir_path); + const size_t path_len = strlen(path); + size_t last_sep = 0; + for (size_t i = 1; i <= path_len; ++i) { + if (path[i] == LV2CORE_DIR_SEP[0]) { + path[i] = '\0'; + if (mkdir(path, 0755) && errno != EEXIST) { + fprintf(stderr, "lv2config: Failed to create %s (%s)\n", + path, strerror(errno)); + free(path); + return 1; + } + path[i] = LV2CORE_DIR_SEP[0]; + last_sep = i; + } + } + + free(path); + return 0; +} + +/** Return the output include dir based on path (prepend DESTDIR). */ +char* +output_dir(const char* path) +{ + char* destdir = getenv("DESTDIR"); + if (destdir) { + size_t len = strlen(destdir) + strlen(path); + char* ret = malloc(len + 1); + snprintf(ret, len + 1, "%s%s", destdir, path); + return ret; + } else { + return strdup(path); + } +} + +/** Build an LV2 include tree in dest for all bunles in lv2_path. */ +void +build_tree(World* world, const char* lv2_path, const char* dest) +{ + free_specs(world); + + /* Call scan_dir for each component of lv2_path, + which will build world->specs (a linked list of struct Spec). + */ + while (lv2_path[0] != '\0') { + const char* const sep = strchr(lv2_path, LV2CORE_PATH_SEP[0]); + if (sep) { + const size_t dir_len = sep - lv2_path; + char* const dir = malloc(dir_len + 1); + memcpy(dir, lv2_path, dir_len); + dir[dir_len] = '\0'; + scan_dir(world, dir); + free(dir); + lv2_path += dir_len + 1; + } else { + scan_dir(world, lv2_path); + lv2_path = "\0"; + } + } + + /* TODO: Check revisions */ + + /* Make a link in the include tree for each specification bundle. */ + for (size_t i = 0; i < world->n_specs; ++i) { + Spec* spec = &world->specs[i]; + const char* path = strchr((const char*)spec->uri.buf, ':'); + if (!path) { + fprintf(stderr, "lv2config: Invalid URI <%s>\n", spec->uri.buf); + continue; + } + for (++path; (path[0] == '/' && path[0] != '\0'); ++path) {} + + const char* bundle_uri = (const char*)spec->manifest.buf; + char* bundle_path = strdup(bundle_uri + strlen("file://")); + char* last_sep = strrchr(bundle_path, LV2CORE_DIR_SEP[0]); + if (last_sep) { + *(last_sep + 1) = '\0'; + } + + char* full_dest = output_dir(dest); + size_t len = strlen(full_dest) + 1 + strlen(path); + char* rel_inc_path = malloc(len + 1); + snprintf(rel_inc_path, len + 1, "%s/%s", full_dest, path); + free(full_dest); + + char* inc_path = expand(rel_inc_path); + free(rel_inc_path); + printf("%s => %s\n", inc_path, bundle_path); + + if (!mkdir_parents(inc_path)) { + if (!access(inc_path, F_OK) && unlink(inc_path)) { + fprintf(stderr, "lv2config: Failed to remove %s (%s)\n", + inc_path, strerror(errno)); + free(inc_path); + free(bundle_path); + continue; + } + + if (symlink(bundle_path, inc_path)) { + fprintf(stderr, "lv2config: Failed to create link (%s)\n", + strerror(errno)); + } + + free(inc_path); + free(bundle_path); + } + } +} + +int +usage(const char* name, bool error) +{ + FILE* out = (error ? stderr : stdout); + fprintf(out, "Usage: %s\n", name); + fprintf(out, "Build the default system LV2 include directories.\n\n"); + fprintf(out, "Usage: %s INCLUDE_DIR\n", name); + fprintf(out, "Build an LV2 include directory tree at INCLUDE_DIR\n"); + fprintf(out, "for all extensions found in $LV2_PATH.\n\n"); + fprintf(out, "Usage: %s INCLUDE_DIR BUNDLES_DIR\n", name); + fprintf(out, "Build an lv2 include directory tree at INCLUDE_DIR\n"); + fprintf(out, "for all extensions found in bundles under BUNDLES_DIR.\n"); + return (error ? EXIT_FAILURE : EXIT_SUCCESS); +} + +int +main(int argc, char** argv) +{ + World world = { NULL, NULL, NULL, NULL, 0 }; + world.reader = serd_reader_new( + SERD_TURTLE, &world, on_base, on_prefix, on_statement, NULL); + + if (argc == 1) { + /* lv2_config */ + build_tree(&world, "/usr/local/lib/lv2", "/usr/local/include/lv2"); + build_tree(&world, "/usr/lib/lv2", "/usr/include/lv2"); + } else if (argv[1][0] == '-') { + return usage(argv[0], false); + } else if (argc == 2) { + /* lv2_config INCLUDE_DIR */ + const char* lv2_path = getenv("LV2_PATH"); + if (!lv2_path) { + lv2_path = LV2CORE_DEFAULT_LV2_PATH; + } + build_tree(&world, lv2_path, argv[1]); + } else if (argc == 3) { + /* lv2_config INCLUDE_DIR BUNDLES_DIR */ + build_tree(&world, argv[2], argv[1]); + } else { + return usage(argv[0], true); + } + + free_specs(&world); + serd_reader_free(world.reader); + + return 0; +} diff --git a/core.lv2/lv2config.py b/core.lv2/lv2config.py deleted file mode 120000 index 7d77275..0000000 --- a/core.lv2/lv2config.py +++ /dev/null @@ -1 +0,0 @@ -lv2config
\ No newline at end of file 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); +} diff --git a/core.lv2/serd-0.1.0.h b/core.lv2/serd-0.1.0.h new file mode 100644 index 0000000..56511b1 --- /dev/null +++ b/core.lv2/serd-0.1.0.h @@ -0,0 +1,634 @@ +/* + 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. +*/ + +/** + @file serd.h API for Serd, a lightweight RDF syntax library. +*/ + +#ifndef SERD_SERD_H +#define SERD_SERD_H + +#include <stdbool.h> +#include <stddef.h> +#include <stdint.h> +#include <stdio.h> + +#ifdef SERD_SHARED + #if defined _WIN32 || defined __CYGWIN__ + #define SERD_LIB_IMPORT __declspec(dllimport) + #define SERD_LIB_EXPORT __declspec(dllexport) + #else + #define SERD_LIB_IMPORT __attribute__ ((visibility("default"))) + #define SERD_LIB_EXPORT __attribute__ ((visibility("default"))) + #endif + #ifdef SERD_INTERNAL + #define SERD_API SERD_LIB_EXPORT + #else + #define SERD_API SERD_LIB_IMPORT + #endif +#else + #define SERD_API +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/** + @defgroup serd Serd + A lightweight RDF syntax library. + @{ +*/ + +/** + Environment (namespace prefixes). + + A SerdEnv represents a set of namespace prefixes, and is used to resolve + CURIEs to full URIs. +*/ +typedef struct SerdEnvImpl* SerdEnv; + +/** + RDF reader. + + A SerdReader parses RDF by reading some syntax and calling user-provided + sink functions as input is read (much like an XML SAX parser). +*/ +typedef struct SerdReaderImpl* SerdReader; + +/** + Read state. + + This represents state (context) necessary for fully resolving URIs during a + read (i.e. the base URI and namespace prefixes). It is implemented + separately from SerdReader so the reader can avoid the overhead in cases + where this information is unnecessary (e.g. streaming reserialisation). +*/ +typedef struct SerdReadStateImpl* SerdReadState; + +/** + RDF writer. + + A SerdWriter provides a number of functions to allow writing RDF syntax out + to some stream. These functions are deliberately compatible with the sink + functions used by SerdReader, so a reader can be directly connected to a + writer to re-serialise a document. +*/ +typedef struct SerdWriterImpl* SerdWriter; + +/** + RDF syntax type. +*/ +typedef enum { + /** + Turtle - Terse RDF Triple Language (UTF-8). + @see <a href="http://www.w3.org/TeamSubmission/turtle/">Turtle</a> + */ + SERD_TURTLE = 1, + + /** + NTriples - Line-based RDF triples (ASCII). + @see <a href="http://www.w3.org/TR/rdf-testcases#ntriples">NTriples</a> + */ + SERD_NTRIPLES = 2 +} SerdSyntax; + +/** + Type of a syntactic RDF node. + + This is more precise than the type of an abstract RDF node. An abstract node + is either a resource, literal, or blank. In syntax there are two ways to + refer to both a resource (by URI or CURIE) and a blank (by ID or + anonymously). + + Serd represents all nodes as an unquoted UTF-8 string "value" associated + with a @ref SerdType, which is precise enough to preserve the syntactic + information required for streaming abbreviation. A non-abbreviating sink may + simply consider @ref SERD_ANON_BEGIN and @ref SERD_ANON equivalent to + @ref SERD_BLANK_ID. +*/ +typedef enum { + /** + The type of a nonexistent node. + + This type is occasionally useful, but is never emitted by the reader. + */ + SERD_NOTHING = 0, + + /** + Literal value. + + A literal optionally has either an associated language, or an associated + datatype (not both). + */ + SERD_LITERAL = 1, + + /** + URI (absolute or relative). + + Value is an unquoted URI string, which is either a relative reference + with respect to the current base URI, or an absolute URI. A URI is an ID + with universal scope. + @see <a href="http://tools.ietf.org/html/rfc3986">RFC3986</a>. + */ + SERD_URI = 2, + + /** + CURIE, a shortened URI. + + Value is an unquoted CURIE string relative to the current environment, + e.g. "rdf:type". + @see <a href="http://www.w3.org/TR/curie">CURIE Syntax 1.0</a> + */ + SERD_CURIE = 3, + + /** + A blank node ID. + + Value is a blank node ID, e.g. "id3", which is valid only in this + serialisation. + @see <a href="http://www.w3.org/TeamSubmission/turtle#nodeID">Turtle + <tt>nodeID</tt></a> + */ + SERD_BLANK_ID = 4, + + /** + The first reference to an anonymous (inlined) blank node. + + Value is identical to a @ref SERD_BLANK_ID value (i.e. this type may be + safely considered equivalent to @ref SERD_BLANK_ID). + */ + SERD_ANON_BEGIN = 5, + + /** + An anonymous blank node. + + Value is identical to a @ref SERD_BLANK_ID value (i.e. this type may be + safely considered equivalent to @ref SERD_BLANK_ID). + */ + SERD_ANON = 6 +} SerdType; + +/** + @name SerdURI + @{ +*/ + +/** + An unterminated string fragment. +*/ +typedef struct { + const uint8_t* buf; /**< Start of chunk */ + size_t len; /**< Length of chunk in bytes */ +} SerdChunk; + +/** + A parsed URI. + + This struct directly refers to chunks in other strings, it does not own any + memory itself. Thus, URIs can be parsed and/or resolved against a base URI + in-place without allocating memory. +*/ +typedef struct { + SerdChunk scheme; /**< Scheme */ + SerdChunk authority; /**< Authority */ + SerdChunk path_base; /**< Path prefix if relative */ + SerdChunk path; /**< Path suffix */ + SerdChunk query; /**< Query */ + SerdChunk fragment; /**< Fragment */ +} SerdURI; + +static const SerdURI SERD_URI_NULL = {{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}}; + +/** + Return true iff @a utf8 starts with a valid URI scheme. +*/ +SERD_API +bool +serd_uri_string_has_scheme(const uint8_t* utf8); + +/** + Parse @a utf8, writing result to @a out. +*/ +SERD_API +bool +serd_uri_parse(const uint8_t* utf8, SerdURI* out); + +/** + Set @a out to @a uri resolved against @a base. +*/ +SERD_API +void +serd_uri_resolve(const SerdURI* uri, const SerdURI* base, SerdURI* out); + +/** + Sink function for raw string output. +*/ +typedef size_t (*SerdSink)(const void* buf, size_t len, void* stream); + +/** + Serialise @a uri with a series of calls to @a sink. +*/ +SERD_API +size_t +serd_uri_serialise(const SerdURI* uri, SerdSink sink, void* stream); + +/** + @} + @name SerdNode + @{ +*/ + +/** + A syntactic RDF node. +*/ +typedef struct { + SerdType type; + size_t n_bytes; /**< Size in bytes (including null) */ + size_t n_chars; /**< Length in characters */ + const uint8_t* buf; /**< Buffer */ +} SerdNode; + +static const SerdNode SERD_NODE_NULL = { SERD_NOTHING, 0, 0, 0 }; + +/** + Make a (shallow) node from @a str. + + This measures, but does not copy, @a str. No memory is allocated. +*/ +SERD_API +SerdNode +serd_node_from_string(SerdType type, const uint8_t* str); + +/** + Make a deep copy of @a node. + + @return a node that the caller must free with @ref serd_node_free. +*/ +SERD_API +SerdNode +serd_node_copy(const SerdNode* node); + +/** + Simple wrapper for serd_node_new_uri to resolve a URI node. +*/ +SERD_API +SerdNode +serd_node_new_uri_from_node(const SerdNode* uri_node, + const SerdURI* base, + SerdURI* out); + +/** + Simple wrapper for serd_node_new_uri to resolve a URI string. +*/ +SERD_API +SerdNode +serd_node_new_uri_from_string(const uint8_t* str, + const SerdURI* base, + SerdURI* out); + +/** + Create a new node by serialising @a uri into a new string. + + @param uri The URI to parse and serialise. + + @param base Base URI to resolve @a uri against (or NULL for no resolution). + + @param out Set to the parsing of the new URI (i.e. points only to + memory owned by the new returned node). +*/ +SERD_API +SerdNode +serd_node_new_uri(const SerdURI* uri, const SerdURI* base, SerdURI* out); + +/** + Free any data owned by @a node. + + Note that if @a node is itself dynamically allocated (which is not the case + for nodes created internally by serd), it will not be freed. +*/ +SERD_API +void +serd_node_free(SerdNode* node); + +/** + @} + @name Handlers + @{ +*/ + +/** + Sink (callback) for base URI changes. + + Called whenever the base URI of the serialisation changes. +*/ +typedef bool (*SerdBaseSink)(void* handle, + const SerdNode* uri); + +/** + Sink (callback) for namespace definitions. + + Called whenever a prefix is defined in the serialisation. +*/ +typedef bool (*SerdPrefixSink)(void* handle, + const SerdNode* name, + const SerdNode* uri); + +/** + Sink (callback) for statements. + + Called for every RDF statement in the serialisation. +*/ +typedef bool (*SerdStatementSink)(void* handle, + const SerdNode* graph, + const SerdNode* subject, + const SerdNode* predicate, + const SerdNode* object, + const SerdNode* object_datatype, + const SerdNode* object_lang); + +/** + Sink (callback) for anonymous node end markers. + + This is called to indicate that the anonymous node with the given + @a value will no longer be referred to by any future statements + (i.e. the anonymous serialisation of the node is finished). +*/ +typedef bool (*SerdEndSink)(void* handle, + const SerdNode* node); + +/** + @} + @name SerdEnv + @{ +*/ + +/** + Create a new environment. +*/ +SERD_API +SerdEnv +serd_env_new(); + +/** + Free @a ns. +*/ +SERD_API +void +serd_env_free(SerdEnv env); + +/** + Add namespace @a uri to @a ns using prefix @a name. +*/ +SERD_API +void +serd_env_add(SerdEnv env, + const SerdNode* name, + const SerdNode* uri); + +/** + Qualify @a into a CURIE if possible. +*/ +SERD_API +bool +serd_env_qualify(const SerdEnv env, + const SerdNode* uri, + SerdNode* prefix, + SerdChunk* suffix); + +/** + Expand @a curie. +*/ +SERD_API +bool +serd_env_expand(const SerdEnv env, + const SerdNode* curie, + SerdChunk* uri_prefix, + SerdChunk* uri_suffix); + +/** + Call @a func for each prefix defined in @a env. +*/ +SERD_API +void +serd_env_foreach(const SerdEnv env, + SerdPrefixSink func, + void* handle); + +/** + @} + @name SerdReader + @{ +*/ + +/** + Create a new RDF reader. +*/ +SERD_API +SerdReader +serd_reader_new(SerdSyntax syntax, + void* handle, + SerdBaseSink base_sink, + SerdPrefixSink prefix_sink, + SerdStatementSink statement_sink, + SerdEndSink end_sink); + +/** + Set a prefix to be added to all blank node identifiers. + + This is useful when multiple files are to be parsed into the same output + (e.g. a store, or other files). Since Serd preserves blank node IDs, this + could cause conflicts where two non-equivalent blank nodes are merged, + resulting in corrupt data. By setting a unique blank node prefix for each + parsed file, this can be avoided, while preserving blank node names. +*/ +SERD_API +void +serd_reader_set_blank_prefix(SerdReader reader, + const uint8_t* prefix); + +/** + Read @a file. +*/ +SERD_API +bool +serd_reader_read_file(SerdReader reader, + FILE* file, + const uint8_t* name); + +/** + Read @a utf8. +*/ +SERD_API +bool +serd_reader_read_string(SerdReader me, const uint8_t* utf8); + +/** + Free @a reader. +*/ +SERD_API +void +serd_reader_free(SerdReader reader); + +/** + Create a new read state with the given initial base URI and environment. + + A reference to @a env will be kept, and @a env will be modified as the + state is modified. +*/ +SERD_API +SerdReadState +serd_read_state_new(SerdEnv env, + const uint8_t* base_uri_str); + +/** + Free @a state. +*/ +SERD_API +void +serd_read_state_free(SerdReadState state); + +/** + Expand @a node to a full URI. + + @param node A CURIE or URI node to expand and/or resolve. +*/ +SERD_API +SerdNode +serd_read_state_expand(SerdReadState state, + const SerdNode* node); + +/** + Get the current base URI. +*/ +SERD_API +SerdNode +serd_read_state_get_base_uri(SerdReadState state, + SerdURI* out); + +/** + Set the current base URI. +*/ +SERD_API +bool +serd_read_state_set_base_uri(SerdReadState state, + const SerdNode* uri_node); + +/** + Set a namespace prefix. +*/ +SERD_API +bool +serd_read_state_set_prefix(SerdReadState state, + const SerdNode* name, + const SerdNode* uri_node); + +/** + @} + @name SerdWriter + @{ +*/ + +typedef enum { + SERD_STYLE_ABBREVIATED = 1, /**< Abbreviate triples when possible. */ + SERD_STYLE_ASCII = 1 << 1, /**< Escape all non-ASCII characters. */ + SERD_STYLE_RESOLVED = 1 << 2, /**< Resolve relative URIs against base. */ + SERD_STYLE_CURIED = 1 << 3 /**< Shorted URIs into CURIEs. */ +} SerdStyle; + +/** + Create a new RDF writer. +*/ +SERD_API +SerdWriter +serd_writer_new(SerdSyntax syntax, + SerdStyle style, + SerdEnv env, + const SerdURI* base_uri, + SerdSink sink, + void* stream); + +/** + Free @a writer. +*/ +SERD_API +void +serd_writer_free(SerdWriter writer); + +/** + Set the current output base URI (and emit directive if applicable). +*/ +SERD_API +void +serd_writer_set_base_uri(SerdWriter writer, + const SerdURI* uri); + +/** + Set a namespace prefix (and emit directive if applicable). +*/ +SERD_API +bool +serd_writer_set_prefix(SerdWriter writer, + const SerdNode* name, + const SerdNode* uri); + +/** + Write a statement. +*/ +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); + +/** + Mark the end of an anonymous node's description. +*/ +SERD_API +bool +serd_writer_end_anon(SerdWriter writer, + const SerdNode* node); + +/** + Finish a write. +*/ +SERD_API +void +serd_writer_finish(SerdWriter writer); + +/** + @} + @} +*/ + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* SERD_SERD_H */ diff --git a/core.lv2/wscript b/core.lv2/wscript index 358a5b0..872dfb9 100644 --- a/core.lv2/wscript +++ b/core.lv2/wscript @@ -15,12 +15,48 @@ top = '.' out = 'build' def options(opt): - opt.add_option('--bundle-only', action='store_true', default=False, dest='bundle_only', - help="Only install LV2 bundle (not header or pkg-config file)") + opt.add_option('--default-lv2-path', type='string', default='', + dest='default_lv2_path', + help="Default LV2 path to use if $LV2_PATH is unset") + opt.add_option('--bundle-only', action='store_true', default=False, + dest='bundle_only', + help="Only install LV2 bundle (not header or pkg-config file)") autowaf.set_options(opt) def configure(conf): autowaf.configure(conf) + lv2core_path_sep = ':' + lv2core_dir_sep = '/' + if sys.platform == 'win32': + lv2core_path_sep = ';' + lv2core_dir_sep = '\\' + + autowaf.define(conf, 'LV2CORE_PATH_SEP', lv2core_path_sep) + autowaf.define(conf, 'LV2CORE_DIR_SEP', lv2core_dir_sep) + + if Options.options.default_lv2_path == '': + if Options.platform == 'darwin': + Options.options.default_lv2_path = lv2core_path_sep.join([ + '~/Library/Audio/Plug-Ins/LV2', + '~/.lv2', + '/usr/local/lib/lv2', + '/usr/lib/lv2', + '/Library/Audio/Plug-Ins/LV2']) + elif Options.platform == 'haiku': + Options.options.default_lv2_path = lv2core_path_sep.join([ + '~/.lv2', + '/boot/common/add-ons/lv2']) + elif Options.platform == 'win32': + Options.options.default_lv2_path = 'C:\\Program Files\\LV2' + else: + Options.options.default_lv2_path = lv2core_path_sep.join([ + '~/.lv2', + '/usr/%s/lv2' % conf.env['LIBDIRNAME'], + '/usr/local/%s/lv2' % conf.env['LIBDIRNAME']]) + + autowaf.define(conf, 'LV2CORE_DEFAULT_LV2_PATH', Options.options.default_lv2_path) + + conf.write_config_header('lv2-config.h', remove=False) def build(bld): # Header "library" @@ -40,10 +76,13 @@ def build(bld): # Bundle (data) bld.install_files('${LV2DIR}/lv2core.lv2', 'lv2.ttl manifest.ttl') - # lv2config - bld.install_files('${BINDIR}', 'lv2config', chmod=0755) + obj = bld(features = 'c cprogram') + obj.source = 'lv2config.c serd-0.1.0.c' + obj.target = 'lv2config' + obj.install_path = '${BINDIR}' + obj.cflags = '-std=c99' def dist(): - import Scripting - Scripting.g_gz = 'gz' + import Scripting + Scripting.g_gz = 'gz' Scripting.dist() |