diff options
26 files changed, 1269 insertions, 1606 deletions
diff --git a/include/lilv/lilv.h b/include/lilv/lilv.h index 1e5f7a0..62fdd82 100644 --- a/include/lilv/lilv.h +++ b/include/lilv/lilv.h @@ -21,6 +21,7 @@ #include "lv2/core/lv2.h" #include "lv2/urid/urid.h" +#include "serd/serd.h" #include <stdarg.h> #include <stdbool.h> @@ -74,7 +75,7 @@ typedef struct LilvPluginClassImpl LilvPluginClass; /**< Plugin Class. */ typedef struct LilvPortImpl LilvPort; /**< Port. */ typedef struct LilvScalePointImpl LilvScalePoint; /**< Scale Point. */ typedef struct LilvUIImpl LilvUI; /**< Plugin UI. */ -typedef struct LilvNodeImpl LilvNode; /**< Typed Value. */ +typedef SerdNode LilvNode; /**< Typed Value. */ typedef struct LilvWorldImpl LilvWorld; /**< Lilv World. */ typedef struct LilvInstanceImpl LilvInstance; /**< Plugin instance. */ typedef struct LilvStateImpl LilvState; /**< Plugin state. */ @@ -103,20 +104,6 @@ lilv_free(void* ptr); */ /** - Convert a file URI string to a local path string. - - For example, "file://foo/bar%20one/baz.ttl" returns "/foo/bar one/baz.ttl". - Return value must be freed by caller with lilv_free(). - - @param uri The file URI to parse. - @param hostname If non-NULL, set to the hostname in the URI, if any. - @return `uri` converted to a path, or NULL on failure (URI is not local). -*/ -LILV_API -char* -lilv_file_uri_parse(const char* uri, char** hostname); - -/** Create a new URI value. Returned value must be freed by caller with lilv_node_free(). @@ -657,7 +644,7 @@ lilv_world_load_all(LilvWorld* world); other things) MUST be identified by URIs (not paths) in save files. */ LILV_API -void +void // FIXME lilv_world_load_bundle(LilvWorld* world, const LilvNode* bundle_uri); /** @@ -668,7 +655,7 @@ lilv_world_load_bundle(LilvWorld* world, const LilvNode* bundle_uri); specifications and adds them to the model. */ LILV_API -void +void // FIXME lilv_world_load_specifications(LilvWorld* world); /** @@ -866,7 +853,7 @@ lilv_plugin_get_uri(const LilvPlugin* plugin); Typical hosts should not need to use this function. Note this always returns a fully qualified URI. If you want a local - filesystem path, use lilv_file_uri_parse(). + filesystem path, use serd_parse_file_uri(). @return A shared string which must not be modified or freed. */ @@ -879,7 +866,7 @@ lilv_plugin_get_bundle_uri(const LilvPlugin* plugin); Typical hosts should not need to use this function. Note this always returns fully qualified URIs. If you want local - filesystem paths, use lilv_file_uri_parse(). + filesystem paths, use serd_parse_file_uri(). @return A list of complete URLs eg. "file:///foo/ABundle.lv2/aplug.ttl", which is shared and must not be modified or freed. @@ -892,7 +879,7 @@ lilv_plugin_get_data_uris(const LilvPlugin* plugin); Get the (resolvable) URI of the shared library for `plugin`. Note this always returns a fully qualified URI. If you want a local - filesystem path, use lilv_file_uri_parse(). + filesystem path, use serd_parse_file_uri(). @return A shared string which must not be modified or freed. */ diff --git a/meson.build b/meson.build index 26eaae8..68ad273 100644 --- a/meson.build +++ b/meson.build @@ -122,16 +122,12 @@ lv2_dep = dependency('lv2', version: '>= 1.18.2', fallback: ['lv2', 'lv2_dep']) -serd_dep = dependency('serd-0', - version: '>= 0.30.9', +serd_dep = dependency('serd-1', + version: '>= 1.0.0', fallback: ['serd', 'serd_dep']) -sord_dep = dependency('sord-0', - version: '>= 0.16.9', - fallback: ['sord', 'sord_dep']) - -sratom_dep = dependency('sratom-0', - version: '>=0.6.9', +sratom_dep = dependency('sratom-1', + version: '>=1.0.0', fallback: ['sratom', 'sratom_dep']) # Determine library type and the flags needed to build it @@ -160,14 +156,14 @@ liblilv = build_target( version: meson.project_version(), include_directories: include_directories(['include', 'src']), c_args: library_args, - dependencies: [m_dep, dl_dep, lv2_dep, serd_dep, sord_dep, sratom_dep], + dependencies: [m_dep, dl_dep, lv2_dep, serd_dep, sratom_dep], gnu_symbol_visibility: 'hidden', install: true, target_type: library_type) lilv_dep = declare_dependency( include_directories: include_directories(['include']), - dependencies: [m_dep, dl_dep, lv2_dep, serd_dep, sord_dep, sratom_dep], + dependencies: [m_dep, dl_dep, lv2_dep, serd_dep, sratom_dep], link_with: liblilv) pkg.generate( @@ -208,7 +204,7 @@ if get_option('tests') sources, include_directories: include_directories(['include', 'src']), c_args: library_args, - dependencies: [m_dep, dl_dep, lv2_dep, serd_dep, sord_dep, sratom_dep], + dependencies: [m_dep, dl_dep, lv2_dep, serd_dep, sratom_dep], gnu_symbol_visibility: 'default') else liblilv_static = liblilv @@ -216,7 +212,7 @@ if get_option('tests') lilv_static_dep = declare_dependency( include_directories: include_directories(['include']), - dependencies: [m_dep, dl_dep, lv2_dep, serd_dep, sord_dep, sratom_dep], + dependencies: [m_dep, dl_dep, lv2_dep, serd_dep, sratom_dep], link_with: liblilv_static) subdir('test') diff --git a/src/collections.c b/src/collections.c index c2c752a..04b0c51 100644 --- a/src/collections.c +++ b/src/collections.c @@ -17,7 +17,7 @@ #include "lilv_internal.h" #include "lilv/lilv.h" -#include "sord/sord.h" +#include "serd/serd.h" #include "zix/common.h" #include "zix/tree.h" @@ -38,10 +38,10 @@ lilv_resource_node_cmp(const void* a, const void* b, const void* user_data) { (void)user_data; - const SordNode* an = ((const LilvNode*)a)->node; - const SordNode* bn = ((const LilvNode*)b)->node; + const SerdNode* const an = (const SerdNode*)a; + const SerdNode* const bn = (const SerdNode*)b; - return (intptr_t)an - (intptr_t)bn; + return serd_node_compare(an, bn); } /* Generic collection functions */ diff --git a/src/instance.c b/src/instance.c index 6a2b856..2c9baa9 100644 --- a/src/instance.c +++ b/src/instance.c @@ -44,7 +44,7 @@ lilv_plugin_instantiate(const LilvPlugin* plugin, } char* const bundle_path = - lilv_file_uri_parse(lilv_node_as_uri(bundle_uri), NULL); + serd_parse_file_uri(lilv_node_as_uri(bundle_uri), NULL); LilvLib* lib = lilv_lib_open(plugin->world, lib_uri, bundle_path, features); if (!lib) { @@ -43,9 +43,8 @@ lilv_lib_open(LilvWorld* world, return llib; } - const char* const lib_uri = lilv_node_as_uri(uri); - char* const lib_path = - (char*)serd_file_uri_parse((const uint8_t*)lib_uri, NULL); + const char* const lib_uri = lilv_node_as_uri(uri); + char* const lib_path = serd_parse_file_uri(lib_uri, NULL); if (!lib_path) { return NULL; } diff --git a/src/lilv_internal.h b/src/lilv_internal.h index 12b56de..89ba122 100644 --- a/src/lilv_internal.h +++ b/src/lilv_internal.h @@ -26,7 +26,6 @@ extern "C" { #include "lilv/lilv.h" #include "lv2/core/lv2.h" #include "serd/serd.h" -#include "sord/sord.h" #include "zix/tree.h" #include <stdbool.h> @@ -64,6 +63,24 @@ dlerror(void) # include "lv2/dynmanifest/dynmanifest.h" #endif +#define LILV_READER_STACK_SIZE 65536 + +#ifndef PAGE_SIZE +# define PAGE_SIZE 4096 +#endif + +#define FOREACH_MATCH(statement_name_, range) \ + for (const SerdStatement* statement_name_ = NULL; \ + !serd_range_empty(range) && \ + (statement_name_ = serd_range_front(range)); \ + serd_range_next(range)) + +#define FOREACH_PAT(name_, model_, s_, p_, o_, g_) \ + for (SerdRange* r_ = serd_model_range(model_, s_, p_, o_, g_); \ + !serd_range_empty(r_) || (serd_range_free(r_), false); \ + serd_range_next(r_)) \ + for (const SerdStatement* name_ = serd_range_front(r_); name_; name_ = NULL) + /* * * Types @@ -80,8 +97,8 @@ struct LilvPortImpl { }; typedef struct LilvSpecImpl { - SordNode* spec; - SordNode* bundle; + SerdNode* spec; + SerdNode* bundle; LilvNodes* data_uris; struct LilvSpecImpl* next; } LilvSpec; @@ -151,8 +168,8 @@ typedef struct { } LilvOptions; struct LilvWorldImpl { - SordWorld* world; - SordModel* model; + SerdWorld* world; + SerdModel* model; SerdReader* reader; unsigned n_read_files; LilvPluginClass* lv2_plugin_class; @@ -163,44 +180,48 @@ struct LilvWorldImpl { LilvNodes* loaded_files; ZixTree* libs; struct { - SordNode* dc_replaces; - SordNode* dman_DynManifest; - SordNode* doap_name; - SordNode* lv2_Plugin; - SordNode* lv2_Specification; - SordNode* lv2_appliesTo; - SordNode* lv2_binary; - SordNode* lv2_default; - SordNode* lv2_designation; - SordNode* lv2_extensionData; - SordNode* lv2_index; - SordNode* lv2_latency; - SordNode* lv2_maximum; - SordNode* lv2_microVersion; - SordNode* lv2_minimum; - SordNode* lv2_minorVersion; - SordNode* lv2_name; - SordNode* lv2_optionalFeature; - SordNode* lv2_port; - SordNode* lv2_portProperty; - SordNode* lv2_reportsLatency; - SordNode* lv2_requiredFeature; - SordNode* lv2_symbol; - SordNode* lv2_prototype; - SordNode* owl_Ontology; - SordNode* pset_value; - SordNode* rdf_a; - SordNode* rdf_value; - SordNode* rdfs_Class; - SordNode* rdfs_label; - SordNode* rdfs_seeAlso; - SordNode* rdfs_subClassOf; - SordNode* xsd_base64Binary; - SordNode* xsd_boolean; - SordNode* xsd_decimal; - SordNode* xsd_double; - SordNode* xsd_integer; - SordNode* null_uri; + SerdNode* dc_replaces; + SerdNode* dman_DynManifest; + SerdNode* doap_name; + SerdNode* lv2_Plugin; + SerdNode* lv2_Specification; + SerdNode* lv2_appliesTo; + SerdNode* lv2_binary; + SerdNode* lv2_default; + SerdNode* lv2_designation; + SerdNode* lv2_extensionData; + SerdNode* lv2_index; + SerdNode* lv2_latency; + SerdNode* lv2_maximum; + SerdNode* lv2_microVersion; + SerdNode* lv2_minimum; + SerdNode* lv2_minorVersion; + SerdNode* lv2_name; + SerdNode* lv2_optionalFeature; + SerdNode* lv2_port; + SerdNode* lv2_portProperty; + SerdNode* lv2_reportsLatency; + SerdNode* lv2_requiredFeature; + SerdNode* lv2_symbol; + SerdNode* lv2_project; + SerdNode* lv2_prototype; + SerdNode* owl_Ontology; + SerdNode* pset_Preset; + SerdNode* pset_value; + SerdNode* rdf_a; + SerdNode* rdf_value; + SerdNode* rdfs_Class; + SerdNode* rdfs_label; + SerdNode* rdfs_seeAlso; + SerdNode* rdfs_subClassOf; + SerdNode* state_state; + SerdNode* xsd_base64Binary; + SerdNode* xsd_boolean; + SerdNode* xsd_decimal; + SerdNode* xsd_double; + SerdNode* xsd_int; + SerdNode* xsd_integer; + SerdNode* null_uri; } uris; LilvOptions opt; }; @@ -215,17 +236,6 @@ typedef enum { LILV_VALUE_BLOB } LilvNodeType; -struct LilvNodeImpl { - LilvWorld* world; - SordNode* node; - LilvNodeType type; - union { - int int_val; - float float_val; - bool bool_val; - } val; -}; - struct LilvScalePointImpl { LilvNode* value; LilvNode* label; @@ -251,46 +261,39 @@ typedef struct LilvVersion { */ LilvPort* -lilv_port_new(LilvWorld* world, - const SordNode* node, - uint32_t index, - const char* symbol); +lilv_port_new(const SerdNode* node, uint32_t index, const char* symbol); void lilv_port_free(const LilvPlugin* plugin, LilvPort* port); LilvPlugin* -lilv_plugin_new(LilvWorld* world, LilvNode* uri, LilvNode* bundle_uri); +lilv_plugin_new(LilvWorld* world, + const LilvNode* uri, + const LilvNode* bundle_uri); void -lilv_plugin_clear(LilvPlugin* plugin, LilvNode* bundle_uri); - +lilv_plugin_clear(LilvPlugin* plugin, const LilvNode* bundle_uri); void lilv_plugin_load_if_necessary(const LilvPlugin* plugin); - void lilv_plugin_free(LilvPlugin* plugin); - LilvNode* lilv_plugin_get_unique(const LilvPlugin* plugin, - const SordNode* subject, - const SordNode* predicate); + const SerdNode* subject, + const SerdNode* predicate); void lilv_collection_free(LilvCollection* collection); - unsigned lilv_collection_size(const LilvCollection* collection); - LilvIter* lilv_collection_begin(const LilvCollection* collection); - void* lilv_collection_get(const LilvCollection* collection, const LilvIter* i); LilvPluginClass* lilv_plugin_class_new(LilvWorld* world, - const SordNode* parent_node, - const SordNode* uri, + const SerdNode* parent_node, + const SerdNode* uri, const char* label); void @@ -324,16 +327,24 @@ LilvUIs* lilv_uis_new(void); LilvNode* +lilv_world_get_manifest_node(LilvWorld* world, const LilvNode* bundle_uri); + +char* +lilv_world_get_manifest_path(LilvWorld* world, const LilvNode* bundle_uri); + +LilvNode* lilv_world_get_manifest_uri(LilvWorld* world, const LilvNode* bundle_uri); -const uint8_t* +const char* lilv_world_blank_node_prefix(LilvWorld* world); SerdStatus lilv_world_load_file(LilvWorld* world, SerdReader* reader, const LilvNode* uri); SerdStatus -lilv_world_load_graph(LilvWorld* world, SordNode* graph, const LilvNode* uri); +lilv_world_load_graph(LilvWorld* world, + const SerdNode* graph, + const LilvNode* uri); LilvUI* lilv_ui_new(LilvWorld* world, @@ -344,12 +355,6 @@ lilv_ui_new(LilvWorld* world, void lilv_ui_free(LilvUI* ui); -LilvNode* -lilv_node_new(LilvWorld* world, LilvNodeType type, const char* str); - -LilvNode* -lilv_node_new_from_node(LilvWorld* world, const SordNode* node); - int lilv_header_compare_by_uri(const void* a, const void* b, const void* user_data); @@ -385,38 +390,22 @@ lilv_scale_point_new(LilvNode* value, LilvNode* label); void lilv_scale_point_free(LilvScalePoint* point); -SordIter* -lilv_world_query_internal(LilvWorld* world, - const SordNode* subject, - const SordNode* predicate, - const SordNode* object); - -bool -lilv_world_ask_internal(LilvWorld* world, - const SordNode* subject, - const SordNode* predicate, - const SordNode* object); - LilvNodes* lilv_world_find_nodes_internal(LilvWorld* world, - const SordNode* subject, - const SordNode* predicate, - const SordNode* object); + const SerdNode* subject, + const SerdNode* predicate, + const SerdNode* object); -SordModel* +SerdModel* lilv_world_filter_model(LilvWorld* world, - SordModel* model, - const SordNode* subject, - const SordNode* predicate, - const SordNode* object, - const SordNode* graph); - -#define FOREACH_MATCH(iter) for (; !sord_iter_end(iter); sord_iter_next(iter)) + SerdModel* model, + const SerdNode* subject, + const SerdNode* predicate, + const SerdNode* object, + const SerdNode* graph); LilvNodes* -lilv_nodes_from_stream_objects(LilvWorld* world, - SordIter* stream, - SordQuadIndex field); +lilv_nodes_from_range(LilvWorld* world, SerdRange* range, SerdField field); char* lilv_strjoin(const char* first, ...); @@ -19,283 +19,103 @@ #include "lilv/lilv.h" #include "serd/serd.h" -#include "sord/sord.h" #include <math.h> #include <stdbool.h> -#include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <string.h> -static void -lilv_node_set_numerics_from_string(LilvNode* val) -{ - const char* str = (const char*)sord_node_get_string(val->node); - - switch (val->type) { - case LILV_VALUE_URI: - case LILV_VALUE_BLANK: - case LILV_VALUE_STRING: - case LILV_VALUE_BLOB: - break; - case LILV_VALUE_INT: - val->val.int_val = strtol(str, NULL, 10); - break; - case LILV_VALUE_FLOAT: - val->val.float_val = serd_strtod(str, NULL); - break; - case LILV_VALUE_BOOL: - val->val.bool_val = !strcmp(str, "true"); - break; - } -} - -/** Note that if `type` is numeric or boolean, the returned value is corrupt - * until lilv_node_set_numerics_from_string is called. It is not - * automatically called from here to avoid overhead and imprecision when the - * exact string value is known. - */ -LilvNode* -lilv_node_new(LilvWorld* world, LilvNodeType type, const char* str) -{ - LilvNode* val = (LilvNode*)malloc(sizeof(LilvNode)); - val->world = world; - val->type = type; - - const uint8_t* ustr = (const uint8_t*)str; - switch (type) { - case LILV_VALUE_URI: - val->node = sord_new_uri(world->world, ustr); - break; - case LILV_VALUE_BLANK: - val->node = sord_new_blank(world->world, ustr); - break; - case LILV_VALUE_STRING: - val->node = sord_new_literal(world->world, NULL, ustr, NULL); - break; - case LILV_VALUE_INT: - val->node = - sord_new_literal(world->world, world->uris.xsd_integer, ustr, NULL); - break; - case LILV_VALUE_FLOAT: - val->node = - sord_new_literal(world->world, world->uris.xsd_decimal, ustr, NULL); - break; - case LILV_VALUE_BOOL: - val->node = - sord_new_literal(world->world, world->uris.xsd_boolean, ustr, NULL); - break; - case LILV_VALUE_BLOB: - val->node = - sord_new_literal(world->world, world->uris.xsd_base64Binary, ustr, NULL); - break; - } - - if (!val->node) { - free(val); - return NULL; - } - - return val; -} - -/** Create a new LilvNode from `node`, or return NULL if impossible */ -LilvNode* -lilv_node_new_from_node(LilvWorld* world, const SordNode* node) -{ - if (!node) { - return NULL; - } - - LilvNode* result = NULL; - SordNode* datatype_uri = NULL; - LilvNodeType type = LILV_VALUE_STRING; - - switch (sord_node_get_type(node)) { - case SORD_URI: - result = (LilvNode*)malloc(sizeof(LilvNode)); - result->world = world; - result->type = LILV_VALUE_URI; - result->node = sord_node_copy(node); - break; - case SORD_BLANK: - result = (LilvNode*)malloc(sizeof(LilvNode)); - result->world = world; - result->type = LILV_VALUE_BLANK; - result->node = sord_node_copy(node); - break; - case SORD_LITERAL: - datatype_uri = sord_node_get_datatype(node); - if (datatype_uri) { - if (sord_node_equals(datatype_uri, world->uris.xsd_boolean)) { - type = LILV_VALUE_BOOL; - } else if (sord_node_equals(datatype_uri, world->uris.xsd_decimal) || - sord_node_equals(datatype_uri, world->uris.xsd_double)) { - type = LILV_VALUE_FLOAT; - } else if (sord_node_equals(datatype_uri, world->uris.xsd_integer)) { - type = LILV_VALUE_INT; - } else if (sord_node_equals(datatype_uri, world->uris.xsd_base64Binary)) { - type = LILV_VALUE_BLOB; - } else { - LILV_ERRORF("Unknown datatype `%s'\n", - sord_node_get_string(datatype_uri)); - } - } - result = - lilv_node_new(world, type, (const char*)sord_node_get_string(node)); - lilv_node_set_numerics_from_string(result); - break; - } - - return result; -} - +LILV_API LilvNode* lilv_new_uri(LilvWorld* world, const char* uri) { - return lilv_node_new(world, LILV_VALUE_URI, uri); + (void)world; + return serd_new_uri(SERD_MEASURE_STRING(uri)); } LilvNode* lilv_new_file_uri(LilvWorld* world, const char* host, const char* path) { - char* abs_path = lilv_path_absolute(path); - SerdNode s = serd_node_new_file_uri( - (const uint8_t*)abs_path, (const uint8_t*)host, NULL, true); + (void)world; + + char* abs_path = lilv_path_absolute(path); + SerdNode* s = + serd_new_file_uri(SERD_MEASURE_STRING(abs_path), SERD_MEASURE_STRING(host)); - LilvNode* ret = lilv_node_new(world, LILV_VALUE_URI, (const char*)s.buf); - serd_node_free(&s); free(abs_path); - return ret; + return s; } LilvNode* lilv_new_string(LilvWorld* world, const char* str) { - return lilv_node_new(world, LILV_VALUE_STRING, str); + (void)world; + + return serd_new_string(SERD_MEASURE_STRING(str)); } LilvNode* lilv_new_int(LilvWorld* world, int val) { - char str[32]; - snprintf(str, sizeof(str), "%d", val); - LilvNode* ret = lilv_node_new(world, LILV_VALUE_INT, str); - if (ret) { - ret->val.int_val = val; - } - return ret; + (void)world; + + return serd_new_integer(val, world->uris.xsd_int); } LilvNode* lilv_new_float(LilvWorld* world, float val) { - char str[32]; - snprintf(str, sizeof(str), "%f", val); - LilvNode* ret = lilv_node_new(world, LILV_VALUE_FLOAT, str); - if (ret) { - ret->val.float_val = val; - } - return ret; + (void)world; + + return serd_new_float(val); } LilvNode* lilv_new_bool(LilvWorld* world, bool val) { - LilvNode* ret = lilv_node_new(world, LILV_VALUE_BOOL, val ? "true" : "false"); - if (ret) { - ret->val.bool_val = val; - } - return ret; + (void)world; + + return serd_new_typed_literal(val ? SERD_STATIC_STRING("true") + : SERD_STATIC_STRING("false"), + serd_node_string_view(world->uris.xsd_boolean)); } LilvNode* lilv_node_duplicate(const LilvNode* val) { - if (!val) { - return NULL; - } - - LilvNode* result = (LilvNode*)malloc(sizeof(LilvNode)); - result->world = val->world; - result->node = sord_node_copy(val->node); - result->val = val->val; - result->type = val->type; - return result; + return serd_node_copy(val); } void lilv_node_free(LilvNode* val) { - if (val) { - sord_node_free(val->world->world, val->node); - free(val); - } + serd_node_free(val); } bool lilv_node_equals(const LilvNode* value, const LilvNode* other) { - if (value == NULL && other == NULL) { - return true; - } - - if (value == NULL || other == NULL || value->type != other->type) { - return false; - } - - switch (value->type) { - case LILV_VALUE_URI: - case LILV_VALUE_BLANK: - case LILV_VALUE_STRING: - case LILV_VALUE_BLOB: - return sord_node_equals(value->node, other->node); - case LILV_VALUE_INT: - return (value->val.int_val == other->val.int_val); - case LILV_VALUE_FLOAT: - return (value->val.float_val == other->val.float_val); - case LILV_VALUE_BOOL: - return (value->val.bool_val == other->val.bool_val); - } - - return false; /* shouldn't get here */ + return serd_node_equals(value, other); } char* lilv_node_get_turtle_token(const LilvNode* value) { - const char* str = (const char*)sord_node_get_string(value->node); + const char* str = serd_node_string(value); size_t len = 0; char* result = NULL; - SerdNode node; - switch (value->type) { - case LILV_VALUE_URI: + if (lilv_node_is_uri(value)) { len = strlen(str) + 3; result = (char*)calloc(len, 1); snprintf(result, len, "<%s>", str); - break; - case LILV_VALUE_BLANK: + } else if (lilv_node_is_blank(value)) { len = strlen(str) + 3; result = (char*)calloc(len, 1); snprintf(result, len, "_:%s", str); - break; - case LILV_VALUE_STRING: - case LILV_VALUE_BOOL: - case LILV_VALUE_BLOB: + } else { result = lilv_strdup(str); - break; - case LILV_VALUE_INT: - node = serd_node_new_integer(value->val.int_val); - result = lilv_strdup((char*)node.buf); - serd_node_free(&node); - break; - case LILV_VALUE_FLOAT: - node = serd_node_new_decimal(value->val.float_val, 8); - result = lilv_strdup((char*)node.buf); - serd_node_free(&node); - break; } return result; @@ -304,110 +124,108 @@ lilv_node_get_turtle_token(const LilvNode* value) bool lilv_node_is_uri(const LilvNode* value) { - return (value && value->type == LILV_VALUE_URI); + return value && serd_node_type(value) == SERD_URI; } const char* lilv_node_as_uri(const LilvNode* value) { - return (lilv_node_is_uri(value) - ? (const char*)sord_node_get_string(value->node) - : NULL); + return (lilv_node_is_uri(value) ? serd_node_string(value) : NULL); } bool lilv_node_is_blank(const LilvNode* value) { - return (value && value->type == LILV_VALUE_BLANK); + return value && serd_node_type(value) == SERD_BLANK; } const char* lilv_node_as_blank(const LilvNode* value) { - return (lilv_node_is_blank(value) - ? (const char*)sord_node_get_string(value->node) - : NULL); + return (lilv_node_is_blank(value) ? serd_node_string(value) : NULL); } bool lilv_node_is_literal(const LilvNode* value) { - if (!value) { - return false; - } - - switch (value->type) { - case LILV_VALUE_STRING: - case LILV_VALUE_INT: - case LILV_VALUE_FLOAT: - case LILV_VALUE_BLOB: - return true; - default: - return false; - } + return value && serd_node_type(value) == SERD_LITERAL; } bool lilv_node_is_string(const LilvNode* value) { - return (value && value->type == LILV_VALUE_STRING); + return value && + (serd_node_type(value) == SERD_LITERAL && !serd_node_datatype(value)); } const char* lilv_node_as_string(const LilvNode* value) { - return value ? (const char*)sord_node_get_string(value->node) : NULL; + return value ? serd_node_string(value) : NULL; } bool lilv_node_is_int(const LilvNode* value) { - return (value && value->type == LILV_VALUE_INT); + if (!value) { + return false; + } + + const SerdNode* const datatype = serd_node_datatype(value); + return (serd_node_type(value) == SERD_LITERAL && datatype && + (!strcmp(serd_node_string(datatype), LILV_NS_XSD "integer") || + !strcmp(serd_node_string(datatype), LILV_NS_XSD "int"))); } int lilv_node_as_int(const LilvNode* value) { - return lilv_node_is_int(value) ? value->val.int_val : 0; + return lilv_node_is_int(value) ? strtoll(serd_node_string(value), NULL, 10) + : 0; } bool lilv_node_is_float(const LilvNode* value) { - return (value && value->type == LILV_VALUE_FLOAT); + if (!value) { + return false; + } + + const SerdNode* const datatype = serd_node_datatype(value); + return (serd_node_type(value) == SERD_LITERAL && datatype && + (!strcmp(serd_node_string(datatype), LILV_NS_XSD "decimal") || + !strcmp(serd_node_string(datatype), LILV_NS_XSD "float") || + !strcmp(serd_node_string(datatype), LILV_NS_XSD "double"))); } float lilv_node_as_float(const LilvNode* value) { - if (lilv_node_is_float(value)) { - return value->val.float_val; - } - - if (lilv_node_is_int(value)) { - return (float)value->val.int_val; - } - - return NAN; + return serd_get_float(value); } bool lilv_node_is_bool(const LilvNode* value) { - return (value && value->type == LILV_VALUE_BOOL); + if (!value) { + return false; + } + + const SerdNode* const datatype = serd_node_datatype(value); + return (serd_node_type(value) == SERD_LITERAL && datatype && + (!strcmp(serd_node_string(datatype), LILV_NS_XSD "boolean"))); } bool lilv_node_as_bool(const LilvNode* value) { - return lilv_node_is_bool(value) ? value->val.bool_val : false; + return (lilv_node_is_bool(value) && !strcmp(serd_node_string(value), "true")); } char* lilv_node_get_path(const LilvNode* value, char** hostname) { - if (lilv_node_is_uri(value)) { - return lilv_file_uri_parse(lilv_node_as_uri(value), hostname); - } - return NULL; + return lilv_node_is_uri(value) + ? serd_parse_file_uri(lilv_node_as_uri(value), hostname) + : NULL; } diff --git a/src/plugin.c b/src/plugin.c index 9c7cbfd..1b34e44 100644 --- a/src/plugin.c +++ b/src/plugin.c @@ -18,7 +18,6 @@ #include "lilv/lilv.h" #include "serd/serd.h" -#include "sord/sord.h" #include "zix/tree.h" #include "lv2/core/lv2.h" @@ -36,13 +35,18 @@ #include <stdlib.h> #include <string.h> -#define NS_DOAP (const uint8_t*)"http://usefulinc.com/ns/doap#" -#define NS_FOAF (const uint8_t*)"http://xmlns.com/foaf/0.1/" +#define NS_DOAP "http://usefulinc.com/ns/doap#" +#define NS_FOAF "http://xmlns.com/foaf/0.1/" +#define NS_LV2 "http://lv2plug.in/ns/lv2core#" +#define NS_OWL "http://www.w3.org/2002/07/owl#" +#define NS_RDF "http://www.w3.org/1999/02/22-rdf-syntax-ns#" +#define NS_RDFS "http://www.w3.org/2000/01/rdf-schema#" +#define NS_XSD "http://www.w3.org/2001/XMLSchema#" static void -lilv_plugin_init(LilvPlugin* plugin, LilvNode* bundle_uri) +lilv_plugin_init(LilvPlugin* plugin, const LilvNode* bundle_uri) { - plugin->bundle_uri = bundle_uri; + plugin->bundle_uri = lilv_node_duplicate(bundle_uri); plugin->binary_uri = NULL; #ifdef LILV_DYN_MANIFEST plugin->dynmanifest = NULL; @@ -56,21 +60,22 @@ lilv_plugin_init(LilvPlugin* plugin, LilvNode* bundle_uri) plugin->replaced = false; } -/** Ownership of `uri` and `bundle` is taken */ LilvPlugin* -lilv_plugin_new(LilvWorld* world, LilvNode* uri, LilvNode* bundle_uri) +lilv_plugin_new(LilvWorld* world, + const LilvNode* uri, + const LilvNode* bundle_uri) { LilvPlugin* plugin = (LilvPlugin*)malloc(sizeof(LilvPlugin)); plugin->world = world; - plugin->plugin_uri = uri; + plugin->plugin_uri = lilv_node_duplicate(uri); lilv_plugin_init(plugin, bundle_uri); return plugin; } void -lilv_plugin_clear(LilvPlugin* plugin, LilvNode* bundle_uri) +lilv_plugin_clear(LilvPlugin* plugin, const LilvNode* bundle_uri) { lilv_node_free(plugin->bundle_uri); lilv_node_free(plugin->binary_uri); @@ -119,37 +124,23 @@ lilv_plugin_free(LilvPlugin* plugin) static LilvNode* lilv_plugin_get_one(const LilvPlugin* plugin, - const SordNode* subject, - const SordNode* predicate) + const SerdNode* subject, + const SerdNode* predicate) { - /* TODO: This is slower than it could be in some cases, but it's simpler to - use the existing i18n code. */ - - SordIter* stream = - lilv_world_query_internal(plugin->world, subject, predicate, NULL); - - LilvNodes* nodes = - lilv_nodes_from_stream_objects(plugin->world, stream, SORD_OBJECT); - - if (nodes) { - LilvNode* value = lilv_node_duplicate(lilv_nodes_get_first(nodes)); - lilv_nodes_free(nodes); - return value; - } - - return NULL; + return serd_node_copy( + serd_model_get(plugin->world->model, subject, predicate, NULL, NULL)); } LilvNode* lilv_plugin_get_unique(const LilvPlugin* plugin, - const SordNode* subject, - const SordNode* predicate) + const SerdNode* subject, + const SerdNode* predicate) { LilvNode* ret = lilv_plugin_get_one(plugin, subject, predicate); if (!ret) { LILV_ERRORF("No value found for (%s %s ...) property\n", - sord_node_get_string(subject), - sord_node_get_string(predicate)); + serd_node_string(subject), + serd_node_string(predicate)); } return ret; } @@ -157,56 +148,59 @@ lilv_plugin_get_unique(const LilvPlugin* plugin, static void lilv_plugin_load(LilvPlugin* plugin) { - SordNode* bundle_uri_node = plugin->bundle_uri->node; - const SerdNode* bundle_uri_snode = sord_node_to_serd_node(bundle_uri_node); + SerdNode* bundle_uri_node = plugin->bundle_uri; - SerdEnv* env = serd_env_new(bundle_uri_snode); - SerdReader* reader = - sord_new_reader(plugin->world->model, env, SERD_TURTLE, bundle_uri_node); + SerdEnv* env = serd_env_new(serd_node_string_view(bundle_uri_node)); + SerdSink* inserter = serd_inserter_new(plugin->world->model, bundle_uri_node); - SordModel* prots = lilv_world_filter_model(plugin->world, + SerdReader* reader = serd_reader_new(plugin->world->world, + SERD_TURTLE, + 0, + env, + inserter, + LILV_READER_STACK_SIZE); + + SerdModel* prots = lilv_world_filter_model(plugin->world, plugin->world->model, - plugin->plugin_uri->node, + plugin->plugin_uri, plugin->world->uris.lv2_prototype, NULL, NULL); - SordModel* skel = sord_new(plugin->world->world, SORD_SPO, false); - SordIter* iter = sord_begin(prots); - for (; !sord_iter_end(iter); sord_iter_next(iter)) { - const SordNode* t = sord_iter_get_node(iter, SORD_OBJECT); - LilvNode* prototype = lilv_node_new_from_node(plugin->world, t); + SerdModel* skel = serd_model_new(plugin->world->world, SERD_INDEX_SPO); + SerdIter* iter = serd_model_begin(prots); + for (; !serd_iter_equals(iter, serd_model_end(prots)); serd_iter_next(iter)) { + const SerdStatement* statement = serd_iter_get(iter); + const SerdNode* t = serd_statement_object(statement); + LilvNode* prototype = serd_node_copy(t); lilv_world_load_resource(plugin->world, prototype); - SordIter* statements = - sord_search(plugin->world->model, prototype->node, NULL, NULL, NULL); - FOREACH_MATCH (statements) { - SordQuad quad; - sord_iter_get(statements, quad); - quad[0] = plugin->plugin_uri->node; - sord_add(skel, quad); + FOREACH_PAT(s, plugin->world->model, prototype, NULL, NULL, NULL) + { + serd_model_add(skel, + plugin->plugin_uri, + serd_statement_predicate(s), + serd_statement_object(s), + NULL); } - sord_iter_free(statements); lilv_node_free(prototype); } - sord_iter_free(iter); + serd_iter_free(iter); - for (iter = sord_begin(skel); !sord_iter_end(iter); sord_iter_next(iter)) { - SordQuad quad; - sord_iter_get(iter, quad); - sord_add(plugin->world->model, quad); - } - sord_iter_free(iter); - sord_free(skel); - sord_free(prots); + SerdRange* all = serd_model_all(skel, SERD_ORDER_SPO); + serd_model_add_range(plugin->world->model, all); + serd_range_free(all); + + serd_model_free(skel); + serd_model_free(prots); // Parse all the plugin's data files into RDF model SerdStatus st = SERD_SUCCESS; LILV_FOREACH (nodes, i, plugin->data_uris) { const LilvNode* data_uri = lilv_nodes_get(plugin->data_uris, i); - serd_env_set_base_uri(env, sord_node_to_serd_node(data_uri->node)); + serd_env_set_base_uri(env, serd_node_string_view(data_uri)); st = lilv_world_load_file(plugin->world, reader, data_uri); if (st > SERD_FAILURE) { break; @@ -217,6 +211,7 @@ lilv_plugin_load(LilvPlugin* plugin) plugin->loaded = true; plugin->parse_errors = true; serd_reader_free(reader); + serd_sink_free(inserter); serd_env_free(env); return; } @@ -229,8 +224,8 @@ lilv_plugin_load(LilvPlugin* plugin) GetDataFunc get_data_func = (GetDataFunc)lilv_dlfunc( plugin->dynmanifest->lib, "lv2_dyn_manifest_get_data"); if (get_data_func) { - const SordNode* bundle = plugin->dynmanifest->bundle->node; - serd_env_set_base_uri(env, sord_node_to_serd_node(bundle)); + const SerdNode* bundle = plugin->dynmanifest->bundle; + serd_env_set_base_uri(env, bundle); FILE* fd = tmpfile(); get_data_func(plugin->dynmanifest->handle, fd, @@ -238,13 +233,13 @@ lilv_plugin_load(LilvPlugin* plugin) rewind(fd); serd_reader_add_blank_prefix(reader, lilv_world_blank_node_prefix(plugin->world)); - serd_reader_read_file_handle( - reader, fd, (const uint8_t*)"(dyn-manifest)"); + serd_reader_read_file_handle(reader, fd, "(dyn-manifest)"); fclose(fd); } } #endif serd_reader_free(reader); + serd_sink_free(inserter); serd_env_free(env); plugin->loaded = true; @@ -273,22 +268,21 @@ lilv_plugin_load_ports_if_necessary(const LilvPlugin* const_plugin) plugin->ports = (LilvPort**)malloc(sizeof(LilvPort*)); plugin->ports[0] = NULL; - SordIter* ports = lilv_world_query_internal(plugin->world, - plugin->plugin_uri->node, - plugin->world->uris.lv2_port, - NULL); - - FOREACH_MATCH (ports) { - const SordNode* port = sord_iter_get_node(ports, SORD_OBJECT); + SerdRange* ports = serd_model_range(plugin->world->model, + plugin->plugin_uri, + plugin->world->uris.lv2_port, + NULL, + NULL); - LilvNode* index = + FOREACH_MATCH (s, ports) { + const SerdNode* port = serd_statement_object(s); + LilvNode* index = lilv_plugin_get_unique(plugin, port, plugin->world->uris.lv2_index); - LilvNode* symbol = lilv_plugin_get_unique(plugin, port, plugin->world->uris.lv2_symbol); if (!lilv_node_is_string(symbol) || - !is_symbol((const char*)sord_node_get_string(symbol->node))) { + !is_symbol(serd_node_string(symbol))) { LILV_ERRORF("Plugin <%s> port symbol `%s' is invalid\n", lilv_node_as_uri(plugin->plugin_uri), lilv_node_as_string(symbol)); @@ -322,30 +316,29 @@ lilv_plugin_load_ports_if_necessary(const LilvPlugin* const_plugin) // Havn't seen this port yet, add it to array if (!this_port) { - this_port = lilv_port_new( - plugin->world, port, this_index, lilv_node_as_string(symbol)); + this_port = + lilv_port_new(port, this_index, lilv_node_as_string(symbol)); plugin->ports[this_index] = this_port; } - SordIter* types = lilv_world_query_internal( - plugin->world, port, plugin->world->uris.rdf_a, NULL); - FOREACH_MATCH (types) { - const SordNode* type = sord_iter_get_node(types, SORD_OBJECT); - if (sord_node_get_type(type) == SORD_URI) { - zix_tree_insert((ZixTree*)this_port->classes, - lilv_node_new_from_node(plugin->world, type), - NULL); + SerdRange* types = serd_model_range( + plugin->world->model, port, plugin->world->uris.rdf_a, NULL, NULL); + FOREACH_MATCH (t, types) { + const SerdNode* type = serd_statement_object(t); + if (serd_node_type(type) == SERD_URI) { + zix_tree_insert( + (ZixTree*)this_port->classes, serd_node_copy(type), NULL); } else { LILV_WARNF("Plugin <%s> port type is not a URI\n", lilv_node_as_uri(plugin->plugin_uri)); } } - sord_iter_free(types); + serd_range_free(types); lilv_node_free(symbol); lilv_node_free(index); } - sord_iter_free(ports); + serd_range_free(ports); // Check sanity for (uint32_t i = 0; i < plugin->num_ports; ++i) { @@ -387,19 +380,19 @@ lilv_plugin_get_library_uri(const LilvPlugin* plugin) lilv_plugin_load_if_necessary((LilvPlugin*)plugin); if (!plugin->binary_uri) { // <plugin> lv2:binary ?binary - SordIter* i = lilv_world_query_internal(plugin->world, - plugin->plugin_uri->node, - plugin->world->uris.lv2_binary, - NULL); - FOREACH_MATCH (i) { - const SordNode* binary_node = sord_iter_get_node(i, SORD_OBJECT); - if (sord_node_get_type(binary_node) == SORD_URI) { - ((LilvPlugin*)plugin)->binary_uri = - lilv_node_new_from_node(plugin->world, binary_node); + SerdRange* i = serd_model_range(plugin->world->model, + plugin->plugin_uri, + plugin->world->uris.lv2_binary, + NULL, + NULL); + FOREACH_MATCH (s, i) { + const SerdNode* binary_node = serd_statement_object(s); + if (serd_node_type(binary_node) == SERD_URI) { + ((LilvPlugin*)plugin)->binary_uri = serd_node_copy(binary_node); break; } } - sord_iter_free(i); + serd_range_free(i); } if (!plugin->binary_uri) { LILV_WARNF("Plugin <%s> has no lv2:binary\n", @@ -420,15 +413,18 @@ lilv_plugin_get_class(const LilvPlugin* plugin) lilv_plugin_load_if_necessary((LilvPlugin*)plugin); if (!plugin->plugin_class) { // <plugin> a ?class - SordIter* c = lilv_world_query_internal( - plugin->world, plugin->plugin_uri->node, plugin->world->uris.rdf_a, NULL); - FOREACH_MATCH (c) { - const SordNode* class_node = sord_iter_get_node(c, SORD_OBJECT); - if (sord_node_get_type(class_node) != SORD_URI) { + SerdRange* c = serd_model_range(plugin->world->model, + plugin->plugin_uri, + plugin->world->uris.rdf_a, + NULL, + NULL); + FOREACH_MATCH (s, c) { + const SerdNode* class_node = serd_statement_object(s); + if (serd_node_type(class_node) != SERD_URI) { continue; } - LilvNode* klass = lilv_node_new_from_node(plugin->world, class_node); + LilvNode* klass = serd_node_copy(class_node); if (!lilv_node_equals(klass, plugin->world->lv2_plugin_class->uri)) { const LilvPluginClass* pclass = lilv_plugin_classes_get_by_uri(plugin->world->plugin_classes, klass); @@ -442,7 +438,7 @@ lilv_plugin_get_class(const LilvPlugin* plugin) lilv_node_free(klass); } - sord_iter_free(c); + serd_range_free(c); if (plugin->plugin_class == NULL) { ((LilvPlugin*)plugin)->plugin_class = plugin->world->lv2_plugin_class; @@ -453,11 +449,11 @@ lilv_plugin_get_class(const LilvPlugin* plugin) static LilvNodes* lilv_plugin_get_value_internal(const LilvPlugin* plugin, - const SordNode* predicate) + const SerdNode* predicate) { lilv_plugin_load_if_necessary(plugin); return lilv_world_find_nodes_internal( - plugin->world, plugin->plugin_uri->node, predicate, NULL); + plugin->world, plugin->plugin_uri, predicate, NULL); } bool @@ -468,9 +464,7 @@ lilv_plugin_verify(const LilvPlugin* plugin) return false; } - LilvNode* rdf_type = lilv_new_uri(plugin->world, LILV_NS_RDF "type"); - LilvNodes* results = lilv_plugin_get_value(plugin, rdf_type); - lilv_node_free(rdf_type); + LilvNodes* results = lilv_plugin_get_value(plugin, plugin->world->uris.rdf_a); if (!results) { return false; } @@ -637,57 +631,47 @@ bool lilv_plugin_has_latency(const LilvPlugin* plugin) { lilv_plugin_load_if_necessary(plugin); - SordIter* ports = lilv_world_query_internal(plugin->world, - plugin->plugin_uri->node, - plugin->world->uris.lv2_port, - NULL); + + SerdRange* ports = serd_model_range(plugin->world->model, + plugin->plugin_uri, + plugin->world->uris.lv2_port, + NULL, + NULL); bool ret = false; - FOREACH_MATCH (ports) { - const SordNode* port = sord_iter_get_node(ports, SORD_OBJECT); - - SordIter* prop = - lilv_world_query_internal(plugin->world, - port, - plugin->world->uris.lv2_portProperty, - plugin->world->uris.lv2_reportsLatency); - - SordIter* des = - lilv_world_query_internal(plugin->world, - port, - plugin->world->uris.lv2_designation, - plugin->world->uris.lv2_latency); - - const bool latent = !sord_iter_end(prop) || !sord_iter_end(des); - sord_iter_free(prop); - sord_iter_free(des); - if (latent) { + FOREACH_MATCH (s, ports) { + const SerdNode* port = serd_statement_object(s); + if (serd_model_ask(plugin->world->model, + port, + plugin->world->uris.lv2_portProperty, + plugin->world->uris.lv2_reportsLatency, + NULL) || + serd_model_ask(plugin->world->model, + port, + plugin->world->uris.lv2_designation, + plugin->world->uris.lv2_latency, + NULL)) { ret = true; break; } } - sord_iter_free(ports); + serd_range_free(ports); return ret; } static const LilvPort* lilv_plugin_get_port_by_property(const LilvPlugin* plugin, - const SordNode* port_property) + const SerdNode* port_property) { lilv_plugin_load_ports_if_necessary(plugin); for (uint32_t i = 0; i < plugin->num_ports; ++i) { LilvPort* port = plugin->ports[i]; - SordIter* iter = - lilv_world_query_internal(plugin->world, - port->node->node, - plugin->world->uris.lv2_portProperty, - port_property); - - const bool found = !sord_iter_end(iter); - sord_iter_free(iter); - - if (found) { + if (serd_model_ask(plugin->world->model, + port->node, + plugin->world->uris.lv2_portProperty, + port_property, + NULL)) { return port; } } @@ -703,16 +687,12 @@ lilv_plugin_get_port_by_designation(const LilvPlugin* plugin, LilvWorld* world = plugin->world; lilv_plugin_load_ports_if_necessary(plugin); for (uint32_t i = 0; i < plugin->num_ports; ++i) { - LilvPort* port = plugin->ports[i]; - SordIter* iter = lilv_world_query_internal( - world, port->node->node, world->uris.lv2_designation, designation->node); - - const bool found = - !sord_iter_end(iter) && - (!port_class || lilv_port_is_a(plugin, port, port_class)); - sord_iter_free(iter); + LilvPort* port = plugin->ports[i]; + const bool has_designation = serd_model_ask( + world->model, port->node, world->uris.lv2_designation, designation, NULL); - if (found) { + if (has_designation && + (!port_class || lilv_port_is_a(plugin, port, port_class))) { return port; } } @@ -749,13 +729,13 @@ bool lilv_plugin_has_feature(const LilvPlugin* plugin, const LilvNode* feature) { lilv_plugin_load_if_necessary(plugin); - const SordNode* predicates[] = {plugin->world->uris.lv2_requiredFeature, + const SerdNode* predicates[] = {plugin->world->uris.lv2_requiredFeature, plugin->world->uris.lv2_optionalFeature, NULL}; - for (const SordNode** pred = predicates; *pred; ++pred) { - if (lilv_world_ask_internal( - plugin->world, plugin->plugin_uri->node, *pred, feature->node)) { + for (const SerdNode** pred = predicates; *pred; ++pred) { + if (serd_model_ask( + plugin->world->model, plugin->plugin_uri, *pred, feature, NULL)) { return true; } } @@ -778,7 +758,7 @@ lilv_plugin_get_optional_features(const LilvPlugin* plugin) { lilv_plugin_load_if_necessary(plugin); return lilv_world_find_nodes_internal(plugin->world, - plugin->plugin_uri->node, + plugin->plugin_uri, plugin->world->uris.lv2_optionalFeature, NULL); } @@ -788,7 +768,7 @@ lilv_plugin_get_required_features(const LilvPlugin* plugin) { lilv_plugin_load_if_necessary(plugin); return lilv_world_find_nodes_internal(plugin->world, - plugin->plugin_uri->node, + plugin->plugin_uri, plugin->world->uris.lv2_requiredFeature, NULL); } @@ -797,16 +777,16 @@ bool lilv_plugin_has_extension_data(const LilvPlugin* plugin, const LilvNode* uri) { if (!lilv_node_is_uri(uri)) { - LILV_ERRORF("Extension data `%s' is not a URI\n", - sord_node_get_string(uri->node)); + LILV_ERRORF("Extension data `%s' is not a URI\n", serd_node_string(uri)); return false; } lilv_plugin_load_if_necessary(plugin); - return lilv_world_ask_internal(plugin->world, - plugin->plugin_uri->node, - plugin->world->uris.lv2_extensionData, - uri->node); + return serd_model_ask(plugin->world->model, + plugin->plugin_uri, + plugin->world->uris.lv2_extensionData, + uri, + NULL); } LilvNodes* @@ -846,73 +826,51 @@ lilv_plugin_get_project(const LilvPlugin* plugin) { lilv_plugin_load_if_necessary(plugin); - SordNode* lv2_project = - sord_new_uri(plugin->world->world, (const uint8_t*)LV2_CORE__project); - - SordIter* projects = lilv_world_query_internal( - plugin->world, plugin->plugin_uri->node, lv2_project, NULL); - - sord_node_free(plugin->world->world, lv2_project); - - if (sord_iter_end(projects)) { - sord_iter_free(projects); - return NULL; - } - - const SordNode* project = sord_iter_get_node(projects, SORD_OBJECT); - - sord_iter_free(projects); - return lilv_node_new_from_node(plugin->world, project); + return serd_node_copy(serd_model_get(plugin->world->model, + plugin->plugin_uri, + plugin->world->uris.lv2_project, + NULL, + NULL)); } -static const SordNode* +static SerdNode* lilv_plugin_get_author(const LilvPlugin* plugin) { lilv_plugin_load_if_necessary(plugin); - SordNode* doap_maintainer = - sord_new_uri(plugin->world->world, NS_DOAP "maintainer"); - - SordIter* maintainers = lilv_world_query_internal( - plugin->world, plugin->plugin_uri->node, doap_maintainer, NULL); + SerdNode* doap_maintainer = + serd_new_uri(SERD_STATIC_STRING(NS_DOAP "maintainer")); - if (sord_iter_end(maintainers)) { - sord_iter_free(maintainers); + const SerdNode* maintainer = serd_model_get( + plugin->world->model, plugin->plugin_uri, doap_maintainer, NULL, NULL); + if (!maintainer) { LilvNode* project = lilv_plugin_get_project(plugin); if (!project) { - sord_node_free(plugin->world->world, doap_maintainer); + serd_node_free(doap_maintainer); return NULL; } - maintainers = lilv_world_query_internal( - plugin->world, project->node, doap_maintainer, NULL); + maintainer = serd_model_get( + plugin->world->model, project, doap_maintainer, NULL, NULL); lilv_node_free(project); } - sord_node_free(plugin->world->world, doap_maintainer); + serd_node_free(doap_maintainer); - if (sord_iter_end(maintainers)) { - sord_iter_free(maintainers); - return NULL; - } - - const SordNode* author = sord_iter_get_node(maintainers, SORD_OBJECT); - - sord_iter_free(maintainers); - return author; + return maintainer ? serd_node_copy(maintainer) : NULL; } static LilvNode* -lilv_plugin_get_author_property(const LilvPlugin* plugin, const uint8_t* uri) +lilv_plugin_get_author_property(const LilvPlugin* plugin, const char* uri) { - const SordNode* author = lilv_plugin_get_author(plugin); + SerdNode* author = lilv_plugin_get_author(plugin); if (author) { - SordWorld* sworld = plugin->world->world; - SordNode* pred = sord_new_uri(sworld, uri); - LilvNode* ret = lilv_plugin_get_one(plugin, author, pred); - sord_node_free(sworld, pred); + SerdNode* pred = serd_new_uri(SERD_MEASURE_STRING(uri)); + LilvNode* ret = lilv_plugin_get_one(plugin, author, pred); + serd_node_free(pred); + serd_node_free(author); return ret; } return NULL; @@ -947,17 +905,15 @@ lilv_plugin_get_uis(const LilvPlugin* plugin) { lilv_plugin_load_if_necessary(plugin); - SordNode* ui_ui_node = - sord_new_uri(plugin->world->world, (const uint8_t*)LV2_UI__ui); - SordNode* ui_binary_node = - sord_new_uri(plugin->world->world, (const uint8_t*)LV2_UI__binary); + SerdNode* ui_ui_node = serd_new_uri(SERD_STATIC_STRING(LV2_UI__ui)); + SerdNode* ui_binary_node = serd_new_uri(SERD_STATIC_STRING(LV2_UI__binary)); - LilvUIs* result = lilv_uis_new(); - SordIter* uis = lilv_world_query_internal( - plugin->world, plugin->plugin_uri->node, ui_ui_node, NULL); + LilvUIs* result = lilv_uis_new(); + SerdRange* uis = serd_model_range( + plugin->world->model, plugin->plugin_uri, ui_ui_node, NULL, NULL); - FOREACH_MATCH (uis) { - const SordNode* ui = sord_iter_get_node(uis, SORD_OBJECT); + FOREACH_MATCH (s, uis) { + const SerdNode* ui = serd_statement_object(s); LilvNode* type = lilv_plugin_get_unique(plugin, ui, plugin->world->uris.rdf_a); @@ -967,30 +923,30 @@ lilv_plugin_get_uis(const LilvPlugin* plugin) binary = lilv_plugin_get_unique(plugin, ui, ui_binary_node); } - if (sord_node_get_type(ui) != SORD_URI || !lilv_node_is_uri(type) || + if (serd_node_type(ui) != SERD_URI || !lilv_node_is_uri(type) || !lilv_node_is_uri(binary)) { lilv_node_free(binary); lilv_node_free(type); - LILV_ERRORF("Corrupt UI <%s>\n", sord_node_get_string(ui)); + LILV_ERRORF("Corrupt UI <%s>\n", serd_node_string(ui)); continue; } - LilvUI* lilv_ui = lilv_ui_new( - plugin->world, lilv_node_new_from_node(plugin->world, ui), type, binary); + LilvUI* lilv_ui = + lilv_ui_new(plugin->world, serd_node_copy(ui), type, binary); zix_tree_insert((ZixTree*)result, lilv_ui, NULL); } - sord_iter_free(uis); + serd_range_free(uis); - sord_node_free(plugin->world->world, ui_binary_node); - sord_node_free(plugin->world->world, ui_ui_node); + serd_node_free(ui_binary_node); + serd_node_free(ui_ui_node); if (lilv_uis_size(result) > 0) { return result; + } else { + lilv_uis_free(result); + return NULL; } - - lilv_uis_free(result); - return NULL; } LilvNodes* @@ -1000,7 +956,7 @@ lilv_plugin_get_related(const LilvPlugin* plugin, const LilvNode* type) LilvWorld* const world = plugin->world; LilvNodes* const related = lilv_world_find_nodes_internal( - world, NULL, world->uris.lv2_appliesTo, lilv_plugin_get_uri(plugin)->node); + world, NULL, world->uris.lv2_appliesTo, lilv_plugin_get_uri(plugin)); if (!type) { return related; @@ -1009,10 +965,8 @@ lilv_plugin_get_related(const LilvPlugin* plugin, const LilvNode* type) LilvNodes* matches = lilv_nodes_new(); LILV_FOREACH (nodes, i, related) { LilvNode* node = (LilvNode*)lilv_collection_get((ZixTree*)related, i); - if (lilv_world_ask_internal( - world, node->node, world->uris.rdf_a, type->node)) { - zix_tree_insert( - (ZixTree*)matches, lilv_node_new_from_node(world, node->node), NULL); + if (serd_model_ask(world->model, node, world->uris.rdf_a, type, NULL)) { + zix_tree_insert((ZixTree*)matches, serd_node_copy(node), NULL); } } @@ -1023,27 +977,32 @@ lilv_plugin_get_related(const LilvPlugin* plugin, const LilvNode* type) static SerdEnv* new_lv2_env(const SerdNode* base) { - SerdEnv* env = serd_env_new(base); - -#define USTR(s) ((const uint8_t*)(s)) - - serd_env_set_prefix_from_strings(env, USTR("doap"), USTR(LILV_NS_DOAP)); - serd_env_set_prefix_from_strings(env, USTR("foaf"), USTR(LILV_NS_FOAF)); - serd_env_set_prefix_from_strings(env, USTR("lv2"), USTR(LILV_NS_LV2)); - serd_env_set_prefix_from_strings(env, USTR("owl"), USTR(LILV_NS_OWL)); - serd_env_set_prefix_from_strings(env, USTR("rdf"), USTR(LILV_NS_RDF)); - serd_env_set_prefix_from_strings(env, USTR("rdfs"), USTR(LILV_NS_RDFS)); - serd_env_set_prefix_from_strings(env, USTR("xsd"), USTR(LILV_NS_XSD)); + SerdEnv* env = serd_env_new(serd_node_string_view(base)); + + serd_env_set_prefix( + env, SERD_STATIC_STRING("doap"), SERD_STATIC_STRING(NS_DOAP)); + serd_env_set_prefix( + env, SERD_STATIC_STRING("foaf"), SERD_STATIC_STRING(NS_FOAF)); + serd_env_set_prefix( + env, SERD_STATIC_STRING("lv2"), SERD_STATIC_STRING(NS_LV2)); + serd_env_set_prefix( + env, SERD_STATIC_STRING("owl"), SERD_STATIC_STRING(NS_OWL)); + serd_env_set_prefix( + env, SERD_STATIC_STRING("rdf"), SERD_STATIC_STRING(NS_RDF)); + serd_env_set_prefix( + env, SERD_STATIC_STRING("rdfs"), SERD_STATIC_STRING(NS_RDFS)); + serd_env_set_prefix( + env, SERD_STATIC_STRING("xsd"), SERD_STATIC_STRING(NS_XSD)); return env; } static void -maybe_write_prefixes(SerdWriter* writer, SerdEnv* env, FILE* file) +maybe_write_prefixes(const SerdSink* sink, SerdEnv* env, FILE* file) { fseek(file, 0, SEEK_END); if (ftell(file) == 0) { - serd_env_foreach(env, (SerdPrefixSink)serd_writer_set_prefix, writer); + serd_env_write_prefixes(env, sink); } else { fprintf(file, "\n"); } @@ -1057,31 +1016,30 @@ lilv_plugin_write_description(LilvWorld* world, { const LilvNode* subject = lilv_plugin_get_uri(plugin); const uint32_t num_ports = lilv_plugin_get_num_ports(plugin); - const SerdNode* base = sord_node_to_serd_node(base_uri->node); + const SerdNode* base = base_uri; SerdEnv* env = new_lv2_env(base); - SerdWriter* writer = - serd_writer_new(SERD_TURTLE, - (SerdStyle)(SERD_STYLE_ABBREVIATED | SERD_STYLE_CURIED), - env, - NULL, - serd_file_sink, - plugin_file); + SerdByteSink* const sink = + serd_byte_sink_new_function((SerdWriteFunc)fwrite, plugin_file, 1); + + SerdWriter* writer = serd_writer_new(world->world, SERD_TURTLE, 0, env, sink); + + const SerdSink* iface = serd_writer_sink(writer); // Write prefixes if this is a new file - maybe_write_prefixes(writer, env, plugin_file); + maybe_write_prefixes(iface, env, plugin_file); // Write plugin description - SordIter* plug_iter = - lilv_world_query_internal(world, subject->node, NULL, NULL); - sord_write_iter(plug_iter, writer); + SerdRange* plug_range = + serd_model_range(world->model, subject, NULL, NULL, NULL); + serd_range_serialise(plug_range, iface, 0); // Write port descriptions for (uint32_t i = 0; i < num_ports; ++i) { const LilvPort* port = plugin->ports[i]; - SordIter* port_iter = - lilv_world_query_internal(world, port->node->node, NULL, NULL); - sord_write_iter(port_iter, writer); + SerdRange* port_range = + serd_model_range(world->model, port->node, NULL, NULL, NULL); + serd_range_serialise(port_range, iface, 0); } serd_writer_free(writer); @@ -1095,45 +1053,37 @@ lilv_plugin_write_manifest_entry(LilvWorld* world, FILE* manifest_file, const char* plugin_file_path) { - (void)world; - const LilvNode* subject = lilv_plugin_get_uri(plugin); - const SerdNode* base = sord_node_to_serd_node(base_uri->node); + const SerdNode* base = base_uri; SerdEnv* env = new_lv2_env(base); - SerdWriter* writer = - serd_writer_new(SERD_TURTLE, - (SerdStyle)(SERD_STYLE_ABBREVIATED | SERD_STYLE_CURIED), - env, - NULL, - serd_file_sink, - manifest_file); + SerdByteSink* const sink = + serd_byte_sink_new_function((SerdWriteFunc)fwrite, manifest_file, 1); + + SerdWriter* writer = serd_writer_new(world->world, SERD_TURTLE, 0, env, sink); + + const SerdSink* iface = serd_writer_sink(writer); // Write prefixes if this is a new file - maybe_write_prefixes(writer, env, manifest_file); + maybe_write_prefixes(iface, env, manifest_file); // Write manifest entry - serd_writer_write_statement( - writer, - 0, - NULL, - sord_node_to_serd_node(subject->node), - sord_node_to_serd_node(plugin->world->uris.rdf_a), - sord_node_to_serd_node(plugin->world->uris.lv2_Plugin), - 0, - 0); - - const SerdNode file_node = - serd_node_from_string(SERD_URI, (const uint8_t*)plugin_file_path); - serd_writer_write_statement( - writer, - 0, - NULL, - sord_node_to_serd_node(subject->node), - sord_node_to_serd_node(plugin->world->uris.rdfs_seeAlso), - &file_node, - 0, - 0); + serd_sink_write(iface, + 0, + subject, + plugin->world->uris.rdf_a, + plugin->world->uris.lv2_Plugin, + NULL); + + const SerdNode* file_node = + serd_new_uri(SERD_MEASURE_STRING(plugin_file_path)); + + serd_sink_write(serd_writer_sink(writer), + 0, + subject, + plugin->world->uris.rdfs_seeAlso, + file_node, + NULL); serd_writer_free(writer); serd_env_free(env); diff --git a/src/pluginclass.c b/src/pluginclass.c index 2f0afe7..96ad2cb 100644 --- a/src/pluginclass.c +++ b/src/pluginclass.c @@ -17,7 +17,7 @@ #include "lilv_internal.h" #include "lilv/lilv.h" -#include "sord/sord.h" +#include "serd/serd.h" #include "zix/tree.h" #include <stdbool.h> @@ -25,16 +25,17 @@ LilvPluginClass* lilv_plugin_class_new(LilvWorld* world, - const SordNode* parent_node, - const SordNode* uri, + const SerdNode* parent_node, + const SerdNode* uri, const char* label) { LilvPluginClass* pc = (LilvPluginClass*)malloc(sizeof(LilvPluginClass)); - pc->world = world; - pc->uri = lilv_node_new_from_node(world, uri); - pc->label = lilv_node_new(world, LILV_VALUE_STRING, label); - pc->parent_uri = - (parent_node ? lilv_node_new_from_node(world, parent_node) : NULL); + + pc->world = world; + pc->uri = serd_node_copy(uri); + pc->label = serd_new_string(SERD_MEASURE_STRING(label)); + pc->parent_uri = (parent_node ? serd_node_copy(parent_node) : NULL); + return pc; } @@ -21,7 +21,7 @@ #include "lv2/event/event.h" #include "lilv/lilv.h" -#include "sord/sord.h" +#include "serd/serd.h" #include "zix/tree.h" #include <assert.h> @@ -31,16 +31,14 @@ #include <stdlib.h> LilvPort* -lilv_port_new(LilvWorld* world, - const SordNode* node, - uint32_t index, - const char* symbol) +lilv_port_new(const SerdNode* node, uint32_t index, const char* symbol) { - LilvPort* port = (LilvPort*)malloc(sizeof(LilvPort)); - port->node = lilv_node_new_from_node(world, node); - port->index = index; - port->symbol = lilv_node_new(world, LILV_VALUE_STRING, symbol); - port->classes = lilv_nodes_new(); + LilvPort* const port = (LilvPort*)malloc(sizeof(LilvPort)); + + port->node = serd_node_copy(node); + port->index = index; + port->symbol = serd_new_string(SERD_MEASURE_STRING(symbol)); + port->classes = lilv_nodes_new(); return port; } @@ -78,10 +76,11 @@ lilv_port_has_property(const LilvPlugin* plugin, const LilvPort* port, const LilvNode* property) { - return lilv_world_ask_internal(plugin->world, - port->node->node, - plugin->world->uris.lv2_portProperty, - property->node); + return serd_model_ask(plugin->world->model, + port->node, + plugin->world->uris.lv2_portProperty, + property, + NULL); } bool @@ -89,15 +88,15 @@ lilv_port_supports_event(const LilvPlugin* plugin, const LilvPort* port, const LilvNode* event_type) { - const uint8_t* predicates[] = {(const uint8_t*)LV2_EVENT__supportsEvent, - (const uint8_t*)LV2_ATOM__supports, - NULL}; - - for (const uint8_t** pred = predicates; *pred; ++pred) { - if (lilv_world_ask_internal(plugin->world, - port->node->node, - sord_new_uri(plugin->world->world, *pred), - event_type->node)) { + const char* predicates[] = { + LV2_EVENT__supportsEvent, LV2_ATOM__supports, NULL}; + + for (const char** pred = predicates; *pred; ++pred) { + if (serd_model_ask(plugin->world->model, + port->node, + serd_new_uri(SERD_MEASURE_STRING(*pred)), + event_type, + NULL)) { return true; } } @@ -107,10 +106,10 @@ lilv_port_supports_event(const LilvPlugin* plugin, static LilvNodes* lilv_port_get_value_by_node(const LilvPlugin* plugin, const LilvPort* port, - const SordNode* predicate) + const SerdNode* predicate) { return lilv_world_find_nodes_internal( - plugin->world, port->node->node, predicate, NULL); + plugin->world, port->node, predicate, NULL); } const LilvNode* @@ -127,12 +126,11 @@ lilv_port_get_value(const LilvPlugin* plugin, const LilvNode* predicate) { if (!lilv_node_is_uri(predicate)) { - LILV_ERRORF("Predicate `%s' is not a URI\n", - sord_node_get_string(predicate->node)); + LILV_ERRORF("Predicate `%s' is not a URI\n", serd_node_string(predicate)); return NULL; } - return lilv_port_get_value_by_node(plugin, port, predicate->node); + return lilv_port_get_value_by_node(plugin, port, predicate); } LilvNode* @@ -231,19 +229,20 @@ lilv_port_get_range(const LilvPlugin* plugin, LilvScalePoints* lilv_port_get_scale_points(const LilvPlugin* plugin, const LilvPort* port) { - SordIter* points = lilv_world_query_internal( - plugin->world, - port->node->node, - sord_new_uri(plugin->world->world, (const uint8_t*)LV2_CORE__scalePoint), - NULL); + SerdRange* points = + serd_model_range(plugin->world->model, + port->node, + serd_new_uri(SERD_STATIC_STRING(LV2_CORE__scalePoint)), + NULL, + NULL); LilvScalePoints* ret = NULL; - if (!sord_iter_end(points)) { + if (!serd_range_empty(points)) { ret = lilv_scale_points_new(); } - FOREACH_MATCH (points) { - const SordNode* point = sord_iter_get_node(points, SORD_OBJECT); + FOREACH_MATCH (s, points) { + const SerdNode* point = serd_statement_object(s); LilvNode* value = lilv_plugin_get_unique(plugin, point, plugin->world->uris.rdf_value); @@ -255,7 +254,7 @@ lilv_port_get_scale_points(const LilvPlugin* plugin, const LilvPort* port) zix_tree_insert((ZixTree*)ret, lilv_scale_point_new(value, label), NULL); } } - sord_iter_free(points); + serd_range_free(points); assert(!ret || lilv_nodes_size(ret) > 0); return ret; @@ -264,9 +263,8 @@ lilv_port_get_scale_points(const LilvPlugin* plugin, const LilvPort* port) LilvNodes* lilv_port_get_properties(const LilvPlugin* plugin, const LilvPort* port) { - LilvNode* pred = lilv_node_new_from_node( - plugin->world, plugin->world->uris.lv2_portProperty); - LilvNodes* ret = lilv_port_get_value(plugin, port, pred); + LilvNode* pred = serd_node_copy(plugin->world->uris.lv2_portProperty); + LilvNodes* ret = lilv_port_get_value(plugin, port, pred); lilv_node_free(pred); return ret; } diff --git a/src/query.c b/src/query.c index eb179f2..b77c2b4 100644 --- a/src/query.c +++ b/src/query.c @@ -17,7 +17,7 @@ #include "lilv_internal.h" #include "lilv/lilv.h" -#include "sord/sord.h" +#include "serd/serd.h" #include "zix/tree.h" #include <stdlib.h> @@ -53,49 +53,48 @@ lilv_lang_matches(const char* a, const char* b) } static LilvNodes* -lilv_nodes_from_stream_objects_i18n(LilvWorld* world, - SordIter* stream, - SordQuadIndex field) +lilv_nodes_from_range_i18n(LilvWorld* world, SerdRange* range, SerdField field) { + (void)world; + LilvNodes* values = lilv_nodes_new(); - const SordNode* nolang = NULL; // Untranslated value - const SordNode* partial = NULL; // Partial language match + const SerdNode* nolang = NULL; // Untranslated value + const SerdNode* partial = NULL; // Partial language match char* syslang = lilv_get_lang(); - FOREACH_MATCH (stream) { - const SordNode* value = sord_iter_get_node(stream, field); - if (sord_node_get_type(value) == SORD_LITERAL) { - const char* lang = sord_node_get_language(value); - - if (!lang) { - nolang = value; + FOREACH_MATCH (s, range) { + const SerdNode* value = serd_statement_node(s, field); + if (serd_node_type(value) == SERD_LITERAL) { + const SerdNode* lang = serd_node_language(value); + LilvLangMatch lm = LILV_LANG_MATCH_NONE; + if (lang) { + lm = (syslang) ? lilv_lang_matches(serd_node_string(lang), syslang) + : LILV_LANG_MATCH_PARTIAL; } else { - switch (lilv_lang_matches(lang, syslang)) { - case LILV_LANG_MATCH_EXACT: - // Exact language match, add to results - zix_tree_insert( - (ZixTree*)values, lilv_node_new_from_node(world, value), NULL); - break; - case LILV_LANG_MATCH_PARTIAL: - // Partial language match, save in case we find no exact - partial = value; - break; - case LILV_LANG_MATCH_NONE: - break; + nolang = value; + if (!syslang) { + lm = LILV_LANG_MATCH_EXACT; } } + + if (lm == LILV_LANG_MATCH_EXACT) { + // Exact language match, add to results + zix_tree_insert((ZixTree*)values, serd_node_copy(value), NULL); + } else if (lm == LILV_LANG_MATCH_PARTIAL) { + // Partial language match, save in case we find no exact + partial = value; + } } else { - zix_tree_insert( - (ZixTree*)values, lilv_node_new_from_node(world, value), NULL); + zix_tree_insert((ZixTree*)values, serd_node_copy(value), NULL); } } - sord_iter_free(stream); + serd_range_free(range); free(syslang); if (lilv_nodes_size(values) > 0) { return values; } - const SordNode* best = nolang; + const SerdNode* best = nolang; if (syslang && partial) { // Partial language match for system language best = partial; @@ -106,8 +105,7 @@ lilv_nodes_from_stream_objects_i18n(LilvWorld* world, } if (best) { - zix_tree_insert( - (ZixTree*)values, lilv_node_new_from_node(world, best), NULL); + zix_tree_insert((ZixTree*)values, serd_node_copy(best), NULL); } else { // No matches whatsoever lilv_nodes_free(values); @@ -118,27 +116,23 @@ lilv_nodes_from_stream_objects_i18n(LilvWorld* world, } LilvNodes* -lilv_nodes_from_stream_objects(LilvWorld* world, - SordIter* stream, - SordQuadIndex field) +lilv_nodes_from_range(LilvWorld* world, SerdRange* range, SerdField field) { - if (sord_iter_end(stream)) { - sord_iter_free(stream); + if (serd_range_empty(range)) { + serd_range_free(range); return NULL; - } - - if (world->opt.filter_language) { - return lilv_nodes_from_stream_objects_i18n(world, stream, field); - } - - LilvNodes* values = lilv_nodes_new(); - FOREACH_MATCH (stream) { - const SordNode* value = sord_iter_get_node(stream, field); - LilvNode* node = lilv_node_new_from_node(world, value); - if (node) { - zix_tree_insert((ZixTree*)values, node, NULL); + } else if (world->opt.filter_language) { + return lilv_nodes_from_range_i18n(world, range, field); + } else { + LilvNodes* values = lilv_nodes_new(); + FOREACH_MATCH (s, range) { + const SerdNode* value = serd_statement_node(s, field); + LilvNode* node = serd_node_copy(value); + if (node) { + zix_tree_insert((ZixTree*)values, node, NULL); + } } + serd_range_free(range); + return values; } - sord_iter_free(stream); - return values; } diff --git a/src/state.c b/src/state.c index d34f761..041d901 100644 --- a/src/state.c +++ b/src/state.c @@ -19,7 +19,6 @@ #include "lilv/lilv.h" #include "serd/serd.h" -#include "sord/sord.h" #include "sratom/sratom.h" #include "zix/tree.h" @@ -38,8 +37,6 @@ #include <stdlib.h> #include <string.h> -#define USTR(s) ((const uint8_t*)(s)) - typedef struct { void* value; ///< Value/Object size_t size; ///< Size of value @@ -127,28 +124,43 @@ path_rel_free(void* ptr) free(ptr); } +static LV2_Atom* +new_atom(const uint32_t size, const uint32_t type, const void* const value) +{ + LV2_Atom* atom = (LV2_Atom*)malloc(sizeof(LV2_Atom) + size); + atom->size = size; + atom->type = type; + memcpy(atom + 1, value, size); + return atom; +} + static PortValue* -append_port_value(LilvState* state, - const char* port_symbol, - const void* value, - uint32_t size, - uint32_t type) +append_port_value(LilvState* state, const char* port_symbol, LV2_Atom* atom) { PortValue* pv = NULL; - if (value) { + if (atom) { state->values = (PortValue*)realloc( state->values, (++state->n_values) * sizeof(PortValue)); - pv = &state->values[state->n_values - 1]; - pv->symbol = lilv_strdup(port_symbol); - pv->atom = (LV2_Atom*)malloc(sizeof(LV2_Atom) + size); - pv->atom->size = size; - pv->atom->type = type; - memcpy(pv->atom + 1, value, size); + pv = &state->values[state->n_values - 1]; + pv->symbol = lilv_strdup(port_symbol); + pv->atom = atom; } return pv; } +static PortValue* +append_port_value_raw(LilvState* state, + const char* port_symbol, + const void* value, + uint32_t size, + uint32_t type) +{ + return value + ? append_port_value(state, port_symbol, new_atom(size, type, value)) + : NULL; +} + static const char* lilv_state_rel2abs(const LilvState* state, const char* path) { @@ -471,7 +483,7 @@ lilv_state_new_from_instance(const LilvPlugin* plugin, uint32_t type = 0; const char* sym = lilv_node_as_string(port->symbol); const void* value = get_value(sym, user_data, &size, &type); - append_port_value(state, sym, value, size, type); + append_port_value_raw(state, sym, value, size, type); } } lilv_node_free(lv2_ControlPort); @@ -498,9 +510,7 @@ lilv_state_new_from_instance(const LilvPlugin* plugin, } } - if (state->values) { - qsort(state->values, state->n_values, sizeof(PortValue), value_cmp); - } + qsort(state->values, state->n_values, sizeof(PortValue), value_cmp); free(sfeatures); return state; @@ -565,27 +575,62 @@ lilv_state_restore(const LilvState* state, } static void -set_state_dir_from_model(LilvState* state, const SordNode* graph) +set_state_dir_from_model(LilvState* state, const SerdNode* graph) { if (!state->dir && graph) { - const char* uri = (const char*)sord_node_get_string(graph); - char* path = lilv_file_uri_parse(uri, NULL); + const char* const uri = serd_node_string(graph); + char* const path = serd_parse_file_uri(uri, NULL); state->dir = lilv_path_join(path, NULL); - free(path); + serd_free(path); } assert(!state->dir || lilv_path_is_absolute(state->dir)); } +static void +add_object_to_properties(SerdModel* model, + const SerdEnv* env, + LV2_URID_Map* map, + const SerdStatement* s, + SratomLoader* loader, + LV2_URID atom_Path, + PropertyArray* props) +{ + const SerdNode* p = serd_statement_predicate(s); + const SerdNode* o = serd_statement_object(s); + const char* key = serd_node_string(p); + + LV2_Atom* atom = sratom_from_model(loader, serd_env_base_uri(env), model, o); + + Property prop = {malloc(atom->size), + atom->size, + map->map(map->handle, key), + atom->type, + LV2_STATE_IS_POD | LV2_STATE_IS_PORTABLE}; + + memcpy(prop.value, LV2_ATOM_BODY_CONST(atom), atom->size); + if (atom->type == atom_Path) { + prop.flags = LV2_STATE_IS_POD; + } + + if (prop.value) { + props->props = + (Property*)realloc(props->props, (++props->n) * sizeof(Property)); + props->props[props->n - 1] = prop; + } + + sratom_free(atom); +} + static LilvState* new_state_from_model(LilvWorld* world, LV2_URID_Map* map, - SordModel* model, - const SordNode* node, + SerdModel* model, + const SerdNode* node, const char* dir) { // Check that we know at least something about this state subject - if (!sord_ask(model, node, 0, 0, 0)) { + if (!serd_model_ask(model, node, 0, 0, 0)) { return NULL; } @@ -593,118 +638,101 @@ new_state_from_model(LilvWorld* world, LilvState* const state = (LilvState*)calloc(1, sizeof(LilvState)); state->dir = lilv_path_join(dir, NULL); state->atom_Path = map->map(map->handle, LV2_ATOM__Path); - state->uri = lilv_node_new_from_node(world, node); + state->uri = serd_node_copy(node); // Get the plugin URI this state applies to - SordIter* i = sord_search(model, node, world->uris.lv2_appliesTo, 0, 0); + SerdIter* i = serd_model_find(model, node, world->uris.lv2_appliesTo, 0, 0); if (i) { - const SordNode* object = sord_iter_get_node(i, SORD_OBJECT); - const SordNode* graph = sord_iter_get_node(i, SORD_GRAPH); - state->plugin_uri = lilv_node_new_from_node(world, object); + const SerdStatement* s = serd_iter_get(i); + const SerdNode* object = serd_statement_object(s); + const SerdNode* graph = serd_statement_graph(s); + state->plugin_uri = serd_node_copy(object); set_state_dir_from_model(state, graph); - sord_iter_free(i); - } else if (sord_ask( + serd_iter_free(i); + } else if (serd_model_ask( model, node, world->uris.rdf_a, world->uris.lv2_Plugin, 0)) { // Loading plugin description as state (default state) - state->plugin_uri = lilv_node_new_from_node(world, node); + state->plugin_uri = serd_node_copy(node); } else { LILV_ERRORF("State %s missing lv2:appliesTo property\n", - sord_node_get_string(node)); + serd_node_string(node)); } // Get the state label - i = sord_search(model, node, world->uris.rdfs_label, NULL, NULL); + i = serd_model_find(model, node, world->uris.rdfs_label, NULL, NULL); if (i) { - const SordNode* object = sord_iter_get_node(i, SORD_OBJECT); - const SordNode* graph = sord_iter_get_node(i, SORD_GRAPH); - state->label = lilv_strdup((const char*)sord_node_get_string(object)); + const SerdStatement* s = serd_iter_get(i); + const SerdNode* object = serd_statement_object(s); + const SerdNode* graph = serd_statement_graph(s); + state->label = lilv_strdup(serd_node_string(object)); set_state_dir_from_model(state, graph); - sord_iter_free(i); + serd_iter_free(i); + } + + SerdEnv* env = serd_env_new(SERD_EMPTY_STRING()); + SratomLoader* loader = sratom_loader_new(world->world, map); + SerdBuffer buffer = {NULL, 0}; + + // Get metadata + SerdRange* meta = serd_model_range(model, node, 0, 0, 0); + FOREACH_MATCH (s, meta) { + const SerdNode* p = serd_statement_predicate(s); + const SerdNode* o = serd_statement_object(s); + if (!serd_node_equals(p, world->uris.state_state) && + !serd_node_equals(p, world->uris.lv2_appliesTo) && + !serd_node_equals(p, world->uris.lv2_port) && + !serd_node_equals(p, world->uris.rdfs_label) && + !serd_node_equals(p, world->uris.rdfs_seeAlso) && + !(serd_node_equals(p, world->uris.rdf_a) && + serd_node_equals(o, world->uris.pset_Preset))) { + add_object_to_properties( + model, env, map, s, loader, state->atom_Path, &state->metadata); + } } - - Sratom* sratom = sratom_new(map); - SerdChunk chunk = {NULL, 0}; - LV2_Atom_Forge forge; - lv2_atom_forge_init(&forge, map); - lv2_atom_forge_set_sink( - &forge, sratom_forge_sink, sratom_forge_deref, &chunk); + serd_range_free(meta); // Get port values - SordIter* ports = sord_search(model, node, world->uris.lv2_port, 0, 0); - FOREACH_MATCH (ports) { - const SordNode* port = sord_iter_get_node(ports, SORD_OBJECT); - - SordNode* label = sord_get(model, port, world->uris.rdfs_label, 0, 0); - SordNode* symbol = sord_get(model, port, world->uris.lv2_symbol, 0, 0); - SordNode* value = sord_get(model, port, world->uris.pset_value, 0, 0); + SerdRange* ports = serd_model_range(model, node, world->uris.lv2_port, 0, 0); + FOREACH_MATCH (s, ports) { + const SerdNode* port = serd_statement_object(s); + + const SerdNode* label = + serd_model_get(model, port, world->uris.rdfs_label, 0, 0); + const SerdNode* symbol = + serd_model_get(model, port, world->uris.lv2_symbol, 0, 0); + const SerdNode* value = + serd_model_get(model, port, world->uris.pset_value, 0, 0); if (!value) { - value = sord_get(model, port, world->uris.lv2_default, 0, 0); + value = serd_model_get(model, port, world->uris.lv2_default, 0, 0); } if (!symbol) { - LILV_ERRORF("State `%s' port missing symbol.\n", - sord_node_get_string(node)); + LILV_ERRORF("State `%s' port missing symbol.\n", serd_node_string(node)); } else if (value) { - chunk.len = 0; - sratom_read(sratom, &forge, world->world, model, value); - const LV2_Atom* atom = (const LV2_Atom*)chunk.buf; - append_port_value(state, - (const char*)sord_node_get_string(symbol), - LV2_ATOM_BODY_CONST(atom), - atom->size, - atom->type); + serd_node_string(symbol), + sratom_from_model(loader, NULL, model, value)); if (label) { - lilv_state_set_label(state, (const char*)sord_node_get_string(label)); + lilv_state_set_label(state, serd_node_string(label)); } } - sord_node_free(world->world, value); - sord_node_free(world->world, symbol); - sord_node_free(world->world, label); } - sord_iter_free(ports); + serd_range_free(ports); // Get properties - SordNode* statep = sord_new_uri(world->world, USTR(LV2_STATE__state)); - SordNode* state_node = sord_get(model, node, statep, NULL, NULL); + const SerdNode* state_node = + serd_model_get(model, node, world->uris.state_state, NULL, NULL); if (state_node) { - SordIter* props = sord_search(model, state_node, 0, 0, 0); - FOREACH_MATCH (props) { - const SordNode* p = sord_iter_get_node(props, SORD_PREDICATE); - const SordNode* o = sord_iter_get_node(props, SORD_OBJECT); - const char* key = (const char*)sord_node_get_string(p); - - chunk.len = 0; - lv2_atom_forge_set_sink( - &forge, sratom_forge_sink, sratom_forge_deref, &chunk); - - sratom_read(sratom, &forge, world->world, model, o); - const LV2_Atom* atom = (const LV2_Atom*)chunk.buf; - uint32_t flags = LV2_STATE_IS_POD | LV2_STATE_IS_PORTABLE; - Property prop = {NULL, 0, 0, 0, flags}; - - prop.key = map->map(map->handle, key); - prop.type = atom->type; - prop.size = atom->size; - prop.value = malloc(atom->size); - memcpy(prop.value, LV2_ATOM_BODY_CONST(atom), atom->size); - if (atom->type == forge.Path) { - prop.flags = LV2_STATE_IS_POD; - } - - if (prop.value) { - state->props.props = (Property*)realloc( - state->props.props, (++state->props.n) * sizeof(Property)); - state->props.props[state->props.n - 1] = prop; - } + SerdRange* props = serd_model_range(model, state_node, 0, 0, 0); + FOREACH_MATCH (s, props) { + add_object_to_properties( + model, env, map, s, loader, state->atom_Path, &state->props); } - sord_iter_free(props); + serd_range_free(props); } - sord_node_free(world->world, state_node); - sord_node_free(world->world, statep); - serd_free((void*)chunk.buf); - sratom_free(sratom); + serd_free(buffer.buf); + sratom_loader_free(loader); if (state->props.props) { qsort(state->props.props, state->props.n, sizeof(Property), property_cmp); @@ -727,7 +755,7 @@ lilv_state_new_from_world(LilvWorld* world, return NULL; } - return new_state_from_model(world, map, world->model, node->node, NULL); + return new_state_from_model(world, map, world->model, node, NULL); } LilvState* @@ -742,17 +770,22 @@ lilv_state_new_from_file(LilvWorld* world, return NULL; } - uint8_t* abs_path = (uint8_t*)lilv_path_absolute(path); - SerdNode node = serd_node_new_file_uri(abs_path, NULL, NULL, true); - SerdEnv* env = serd_env_new(&node); - SordModel* model = sord_new(world->world, SORD_SPO, false); - SerdReader* reader = sord_new_reader(model, env, SERD_TURTLE, NULL); + char* abs_path = lilv_path_absolute(path); + SerdNode* node = + serd_new_file_uri(SERD_MEASURE_STRING(abs_path), SERD_EMPTY_STRING()); + SerdEnv* env = serd_env_new(serd_node_string_view(node)); + SerdModel* model = serd_model_new(world->world, SERD_INDEX_SPO); + SerdSink* inserter = serd_inserter_new(model, NULL); + SerdReader* reader = serd_reader_new( + world->world, SERD_TURTLE, 0, env, inserter, LILV_READER_STACK_SIZE); - serd_reader_read_file(reader, node.buf); + SerdByteSource* source = serd_byte_source_new_filename(abs_path, 4096); + serd_reader_start(reader, source); + serd_reader_read_document(reader); + serd_reader_finish(reader); + serd_byte_source_free(source); - SordNode* subject_node = - (subject) ? subject->node - : sord_node_from_serd_node(world->world, env, &node, NULL, NULL); + const SerdNode* subject_node = subject ? subject : node; char* dirname = lilv_path_parent(path); char* real_path = lilv_path_canonical(dirname); @@ -763,10 +796,10 @@ lilv_state_new_from_file(LilvWorld* world, free(real_path); free(dirname); - serd_node_free(&node); + serd_node_free(node); free(abs_path); serd_reader_free(reader); - sord_free(model); + serd_model_free(model); serd_env_free(env); return state; } @@ -774,14 +807,16 @@ lilv_state_new_from_file(LilvWorld* world, static void set_prefixes(SerdEnv* env) { -#define SET_PSET(e, p, u) serd_env_set_prefix_from_strings(e, p, u) - SET_PSET(env, USTR("atom"), USTR(LV2_ATOM_PREFIX)); - SET_PSET(env, USTR("lv2"), USTR(LV2_CORE_PREFIX)); - SET_PSET(env, USTR("pset"), USTR(LV2_PRESETS_PREFIX)); - SET_PSET(env, USTR("rdf"), USTR(LILV_NS_RDF)); - SET_PSET(env, USTR("rdfs"), USTR(LILV_NS_RDFS)); - SET_PSET(env, USTR("state"), USTR(LV2_STATE_PREFIX)); - SET_PSET(env, USTR("xsd"), USTR(LILV_NS_XSD)); +#define SET_PSET(e, p, u) \ + serd_env_set_prefix(e, SERD_STATIC_STRING(p), SERD_STATIC_STRING(u)) + + SET_PSET(env, "atom", LV2_ATOM_PREFIX); + SET_PSET(env, "lv2", LV2_CORE_PREFIX); + SET_PSET(env, "pset", LV2_PRESETS_PREFIX); + SET_PSET(env, "rdf", LILV_NS_RDF); + SET_PSET(env, "rdfs", LILV_NS_RDFS); + SET_PSET(env, "state", LV2_STATE_PREFIX); + SET_PSET(env, "xsd", LILV_NS_XSD); } LilvState* @@ -791,47 +826,43 @@ lilv_state_new_from_string(LilvWorld* world, LV2_URID_Map* map, const char* str) return NULL; } - SerdNode base = SERD_NODE_NULL; - SerdEnv* env = serd_env_new(&base); - SordModel* model = sord_new(world->world, SORD_SPO | SORD_OPS, false); - SerdReader* reader = sord_new_reader(model, env, SERD_TURTLE, NULL); + SerdEnv* env = serd_env_new(SERD_EMPTY_STRING()); + SerdModel* model = + serd_model_new(world->world, SERD_INDEX_SPO | SERD_INDEX_OPS); + SerdSink* inserter = serd_inserter_new(model, NULL); + SerdReader* reader = serd_reader_new( + world->world, SERD_TURTLE, 0, env, inserter, LILV_READER_STACK_SIZE); + SerdByteSource* source = serd_byte_source_new_string(str, NULL); set_prefixes(env); - serd_reader_read_string(reader, USTR(str)); + serd_reader_start(reader, source); + serd_reader_read_document(reader); - SordNode* o = sord_new_uri(world->world, USTR(LV2_PRESETS__Preset)); - SordNode* s = sord_get(model, NULL, world->uris.rdf_a, o, NULL); + SerdNode* o = serd_new_uri(SERD_STATIC_STRING(LV2_PRESETS__Preset)); + const SerdNode* s = serd_model_get(model, NULL, world->uris.rdf_a, o, NULL); LilvState* state = new_state_from_model(world, map, model, s, NULL); - sord_node_free(world->world, s); - sord_node_free(world->world, o); + serd_node_free(o); + serd_byte_source_free(source); serd_reader_free(reader); - sord_free(model); + serd_model_free(model); serd_env_free(env); return state; } static SerdWriter* -ttl_writer(SerdSink sink, void* stream, const SerdNode* base, SerdEnv** new_env) +ttl_writer(SerdWorld* world, + SerdByteSink* const sink, + const SerdNode* base, + SerdEnv** new_env) { - SerdURI base_uri = SERD_URI_NULL; - if (base && base->buf) { - serd_uri_parse(base->buf, &base_uri); - } - - SerdEnv* env = *new_env ? *new_env : serd_env_new(base); + SerdEnv* env = + *new_env ? *new_env : serd_env_new(serd_node_string_view(base)); set_prefixes(env); - SerdWriter* writer = - serd_writer_new(SERD_TURTLE, - (SerdStyle)(SERD_STYLE_RESOLVED | SERD_STYLE_ABBREVIATED | - SERD_STYLE_CURIED), - env, - &base_uri, - sink, - stream); + SerdWriter* writer = serd_writer_new(world, SERD_TURTLE, 0, env, sink); if (!*new_env) { *new_env = env; @@ -841,13 +872,16 @@ ttl_writer(SerdSink sink, void* stream, const SerdNode* base, SerdEnv** new_env) } static SerdWriter* -ttl_file_writer(FILE* fd, const SerdNode* node, SerdEnv** env) +ttl_file_writer(SerdWorld* world, FILE* fd, const SerdNode* node, SerdEnv** env) { - SerdWriter* writer = ttl_writer(serd_file_sink, fd, node, env); + SerdByteSink* const sink = + serd_byte_sink_new_function((SerdWriteFunc)fwrite, fd, 1); + + SerdWriter* const writer = ttl_writer(world, sink, node, env); fseek(fd, 0, SEEK_END); if (ftell(fd) == 0) { - serd_env_foreach(*env, (SerdPrefixSink)serd_writer_set_prefix, writer); + serd_env_write_prefixes(*env, serd_writer_sink(writer)); } else { fprintf(fd, "\n"); } @@ -856,47 +890,27 @@ ttl_file_writer(FILE* fd, const SerdNode* node, SerdEnv** env) } static void -add_to_model(SordWorld* world, - SerdEnv* env, - SordModel* model, - const SerdNode s, - const SerdNode p, - const SerdNode o) +remove_manifest_entry(SerdModel* model, const char* subject) { - SordNode* ss = sord_node_from_serd_node(world, env, &s, NULL, NULL); - SordNode* sp = sord_node_from_serd_node(world, env, &p, NULL, NULL); - SordNode* so = sord_node_from_serd_node(world, env, &o, NULL, NULL); + SerdNode* const s = serd_new_uri(SERD_MEASURE_STRING(subject)); + SerdRange* const r = serd_model_range(model, s, NULL, NULL, NULL); - SordQuad quad = {ss, sp, so, NULL}; - sord_add(model, quad); - - sord_node_free(world, ss); - sord_node_free(world, sp); - sord_node_free(world, so); -} + serd_model_erase_range(model, r); -static void -remove_manifest_entry(SordWorld* world, SordModel* model, const char* subject) -{ - SordNode* s = sord_new_uri(world, USTR(subject)); - SordIter* i = sord_search(model, s, NULL, NULL, NULL); - while (!sord_iter_end(i)) { - sord_erase(model, i); - } - sord_iter_free(i); - sord_node_free(world, s); + serd_range_free(r); + serd_node_free(s); } static int write_manifest(LilvWorld* world, SerdEnv* env, - SordModel* model, + SerdModel* model, const SerdNode* file_uri) { - (void)world; + const char* file_uri_str = serd_node_string(file_uri); + char* const path = serd_parse_file_uri(file_uri_str, NULL); + FILE* const wfd = fopen(path, "w"); - char* const path = (char*)serd_file_uri_parse(file_uri->buf, NULL); - FILE* const wfd = fopen(path, "w"); if (!wfd) { LILV_ERRORF("Failed to open %s for writing (%s)\n", path, strerror(errno)); @@ -904,8 +918,10 @@ write_manifest(LilvWorld* world, return 1; } - SerdWriter* writer = ttl_file_writer(wfd, file_uri, &env); - sord_write(model, writer, NULL); + SerdWriter* writer = ttl_file_writer(world->world, wfd, file_uri, &env); + SerdRange* all = serd_model_all(model, SERD_ORDER_SPO); + serd_range_serialise(all, serd_writer_sink(writer), 0); + serd_range_free(all); serd_writer_free(writer); fclose(wfd); serd_free(path); @@ -919,90 +935,73 @@ add_state_to_manifest(LilvWorld* lworld, const char* state_uri, const char* state_path) { - SordWorld* world = lworld->world; - SerdNode manifest = serd_node_new_file_uri(USTR(manifest_path), 0, 0, 1); - SerdNode file = serd_node_new_file_uri(USTR(state_path), 0, 0, 1); - SerdEnv* env = serd_env_new(&manifest); - SordModel* model = sord_new(world, SORD_SPO, false); + static const SerdStringView empty = {"", 0}; + + const SerdStringView manifest_path_view = SERD_MEASURE_STRING(manifest_path); + const SerdStringView state_path_view = SERD_MEASURE_STRING(state_path); + + SerdWorld* world = lworld->world; + SerdNode* manifest = serd_new_file_uri(manifest_path_view, empty); + SerdNode* file = serd_new_file_uri(state_path_view, empty); + SerdEnv* env = serd_env_new(serd_node_string_view(manifest)); + SerdModel* model = serd_model_new(world, SERD_INDEX_SPO | SERD_INDEX_OPS); + SerdSink* inserter = serd_inserter_new(model, NULL); - if (lilv_path_exists(manifest_path)) { + FILE* const rfd = fopen(manifest_path, "r"); + if (rfd) { // Read manifest into model - SerdReader* reader = sord_new_reader(model, env, SERD_TURTLE, NULL); - SerdStatus st = serd_reader_read_file(reader, manifest.buf); - if (st) { + SerdReader* reader = serd_reader_new( + world, SERD_TURTLE, 0, env, inserter, LILV_READER_STACK_SIZE); + + SerdByteSource* source = + serd_byte_source_new_function((SerdReadFunc)fread, + (SerdStreamErrorFunc)ferror, + rfd, + manifest, + PAGE_SIZE); + + SerdStatus st = SERD_SUCCESS; + if ((st = serd_reader_start(reader, source)) || + (st = serd_reader_read_document(reader))) { LILV_WARNF("Failed to read manifest (%s)\n", serd_strerror(st)); + return st; } + + serd_byte_source_free(source); serd_reader_free(reader); + fclose(rfd); } // Choose state URI (use file URI if not given) if (!state_uri) { - state_uri = (const char*)file.buf; + state_uri = serd_node_string(file); } // Remove any existing manifest entries for this state - remove_manifest_entry(world, model, state_uri); + remove_manifest_entry(model, state_uri); // Add manifest entry for this state to model - SerdNode s = serd_node_from_string(SERD_URI, USTR(state_uri)); - - // <state> a pset:Preset - add_to_model(world, - env, - model, - s, - serd_node_from_string(SERD_URI, USTR(LILV_NS_RDF "type")), - serd_node_from_string(SERD_URI, USTR(LV2_PRESETS__Preset))); + SerdNode* s = serd_new_uri(SERD_MEASURE_STRING(state_uri)); // <state> a pset:Preset - add_to_model(world, - env, - model, - s, - serd_node_from_string(SERD_URI, USTR(LILV_NS_RDF "type")), - serd_node_from_string(SERD_URI, USTR(LV2_PRESETS__Preset))); + serd_model_add(model, s, lworld->uris.rdf_a, lworld->uris.pset_Preset, NULL); // <state> rdfs:seeAlso <file> - add_to_model(world, - env, - model, - s, - serd_node_from_string(SERD_URI, USTR(LILV_NS_RDFS "seeAlso")), - file); + serd_model_add(model, s, lworld->uris.rdfs_seeAlso, file, NULL); // <state> lv2:appliesTo <plugin> - add_to_model( - world, - env, - model, - s, - serd_node_from_string(SERD_URI, USTR(LV2_CORE__appliesTo)), - serd_node_from_string(SERD_URI, USTR(lilv_node_as_string(plugin_uri)))); - - /* Re-open manifest for locked writing. We need to do this because it may - need to be truncated, and the file can only be open once on Windows. */ - - FILE* wfd = fopen(manifest_path, "wb"); - int r = 0; - if (!wfd) { - LILV_ERRORF( - "Failed to open %s for writing (%s)\n", manifest_path, strerror(errno)); - r = 1; - } + serd_model_add(model, s, lworld->uris.lv2_appliesTo, plugin_uri, NULL); - SerdWriter* writer = ttl_file_writer(wfd, &manifest, &env); - lilv_flock(wfd, true, true); - sord_write(model, writer, NULL); - lilv_flock(wfd, false, true); - serd_writer_free(writer); - fclose(wfd); + // Write manifest model to file + write_manifest(lworld, env, model, manifest); - sord_free(model); - serd_node_free(&file); - serd_node_free(&manifest); + serd_node_free(s); + serd_model_free(model); + serd_node_free(file); + serd_node_free(manifest); serd_env_free(env); - return r; + return 0; } static bool @@ -1037,138 +1036,148 @@ maybe_symlink(const char* oldpath, const char* newpath) static void write_property_array(const LilvState* state, const PropertyArray* array, - Sratom* sratom, - uint32_t flags, + const SerdEnv* env, + SratomDumper* dumper, + const SerdSink* sink, const SerdNode* subject, LV2_URID_Unmap* unmap, const char* dir) { + // FIXME: error handling for (uint32_t i = 0; i < array->n; ++i) { Property* prop = &array->props[i]; const char* key = unmap->unmap(unmap->handle, prop->key); - const SerdNode p = serd_node_from_string(SERD_URI, USTR(key)); + SerdNode* p = serd_new_uri(SERD_MEASURE_STRING(key)); if (prop->type == state->atom_Path && !dir) { const char* path = (const char*)prop->value; const char* abs_path = lilv_state_rel2abs(state, path); LILV_WARNF("Writing absolute path %s\n", abs_path); - sratom_write(sratom, - unmap, - flags, - subject, - &p, - prop->type, - strlen(abs_path) + 1, - abs_path); + sratom_dump(dumper, + env, + sink, + subject, + p, + prop->type, + strlen(abs_path) + 1, + abs_path, + 0); } else if (prop->flags & LV2_STATE_IS_POD || prop->type == state->atom_Path) { - sratom_write( - sratom, unmap, flags, subject, &p, prop->type, prop->size, prop->value); + sratom_dump( + dumper, env, sink, subject, p, prop->type, prop->size, prop->value, 0); } else { LILV_WARNF("Lost non-POD property <%s> on save\n", key); } + serd_node_free(p); } } -static int +static SerdStatus lilv_state_write(LilvWorld* world, LV2_URID_Map* map, LV2_URID_Unmap* unmap, const LilvState* state, + const SerdEnv* env, SerdWriter* writer, const char* uri, const char* dir) { - (void)world; + const SerdSink* sink = serd_writer_sink(writer); + const SerdNode* plugin_uri = state->plugin_uri; + SerdNode* subject = + serd_new_uri(uri ? SERD_MEASURE_STRING(uri) : SERD_EMPTY_STRING()); - SerdNode lv2_appliesTo = - serd_node_from_string(SERD_CURIE, USTR("lv2:appliesTo")); - - const SerdNode* plugin_uri = sord_node_to_serd_node(state->plugin_uri->node); - - SerdNode subject = serd_node_from_string(SERD_URI, USTR(uri ? uri : "")); + SerdStatus st = SERD_SUCCESS; // <subject> a pset:Preset - SerdNode p = serd_node_from_string(SERD_URI, USTR(LILV_NS_RDF "type")); - SerdNode o = serd_node_from_string(SERD_URI, USTR(LV2_PRESETS__Preset)); - serd_writer_write_statement(writer, 0, NULL, &subject, &p, &o, NULL, NULL); + if ((st = serd_sink_write( + sink, 0, subject, world->uris.rdf_a, world->uris.pset_Preset, NULL))) { + return st; + } // <subject> lv2:appliesTo <http://example.org/plugin> - serd_writer_write_statement( - writer, 0, NULL, &subject, &lv2_appliesTo, plugin_uri, NULL, NULL); + if ((st = serd_sink_write( + sink, 0, subject, world->uris.lv2_appliesTo, plugin_uri, NULL))) { + return st; + } // <subject> rdfs:label label if (state->label) { - p = serd_node_from_string(SERD_URI, USTR(LILV_NS_RDFS "label")); - o = serd_node_from_string(SERD_LITERAL, USTR(state->label)); - serd_writer_write_statement(writer, 0, NULL, &subject, &p, &o, NULL, NULL); - } + SerdNode* label = serd_new_string(SERD_MEASURE_STRING(state->label)); + if ((st = serd_sink_write( + sink, 0, subject, world->uris.rdfs_label, label, NULL))) { + return st; + } - SerdEnv* env = serd_writer_get_env(writer); - const SerdNode* base = serd_env_get_base_uri(env, NULL); + serd_node_free(label); + } - Sratom* sratom = sratom_new(map); - sratom_set_sink(sratom, - (const char*)base->buf, - (SerdStatementSink)serd_writer_write_statement, - (SerdEndSink)serd_writer_end_anon, - writer); + SratomDumper* dumper = sratom_dumper_new(world->world, map, unmap); - // Write metadata - sratom_set_pretty_numbers(sratom, false); // Use precise types + // Write metadata (with precise types) write_property_array( - state, &state->metadata, sratom, 0, &subject, unmap, dir); + state, &state->metadata, env, dumper, sink, subject, unmap, dir); - // Write port values - sratom_set_pretty_numbers(sratom, true); // Use pretty numbers + // Write port values (with pretty numbers) for (uint32_t i = 0; i < state->n_values; ++i) { PortValue* const value = &state->values[i]; - - const SerdNode port = - serd_node_from_string(SERD_BLANK, USTR(value->symbol)); + SerdNode* port = serd_new_blank(SERD_MEASURE_STRING(value->symbol)); // <> lv2:port _:symbol - p = serd_node_from_string(SERD_URI, USTR(LV2_CORE__port)); - serd_writer_write_statement( - writer, SERD_ANON_O_BEGIN, NULL, &subject, &p, &port, NULL, NULL); + if ((st = serd_sink_write( + sink, SERD_ANON_O, subject, world->uris.lv2_port, port, NULL))) { + return st; + } // _:symbol lv2:symbol "symbol" - p = serd_node_from_string(SERD_URI, USTR(LV2_CORE__symbol)); - o = serd_node_from_string(SERD_LITERAL, USTR(value->symbol)); - serd_writer_write_statement( - writer, SERD_ANON_CONT, NULL, &port, &p, &o, NULL, NULL); + SerdNode* symbol = serd_new_string(SERD_MEASURE_STRING(value->symbol)); + if ((st = serd_sink_write( + sink, 0, port, world->uris.lv2_symbol, symbol, NULL))) { + return st; + } - // _:symbol pset:value value - p = serd_node_from_string(SERD_URI, USTR(LV2_PRESETS__value)); - sratom_write(sratom, - unmap, - SERD_ANON_CONT, - &port, - &p, - value->atom->type, - value->atom->size, - value->atom + 1); + serd_node_free(symbol); - serd_writer_end_anon(writer, &port); + // _:symbol pset:value value + // FIXME: error handling + sratom_dump_atom(dumper, + env, + sink, + port, + world->uris.pset_value, + value->atom, + 0); // SRATOM_PRETTY_NUMBERS); + + if ((st = serd_sink_write_end(sink, port))) { + return st; + } } - // Write properties - const SerdNode body = serd_node_from_string(SERD_BLANK, USTR("body")); + // <> state:state _:body + + SerdNode* body = serd_new_blank(SERD_STATIC_STRING("body")); if (state->props.n > 0) { - p = serd_node_from_string(SERD_URI, USTR(LV2_STATE__state)); - serd_writer_write_statement( - writer, SERD_ANON_O_BEGIN, NULL, &subject, &p, &body, NULL, NULL); + if ((st = serd_sink_write( + sink, SERD_ANON_O, subject, world->uris.state_state, body, NULL))) { + return st; + } } - sratom_set_pretty_numbers(sratom, false); // Use precise types + + // _:body key value ... write_property_array( - state, &state->props, sratom, SERD_ANON_CONT, &body, unmap, dir); + state, &state->props, env, dumper, sink, body, unmap, dir); + // End state body if (state->props.n > 0) { - serd_writer_end_anon(writer, &body); + if ((st = serd_sink_write_end(sink, body))) { + return st; + } } - sratom_free(sratom); - return 0; + serd_node_free(body); + sratom_dumper_free(dumper); + return SERD_SUCCESS; } static void @@ -1229,7 +1238,7 @@ lilv_state_save(LilvWorld* world, return 1; } - char* abs_dir = real_dir(dir); + char* abs_dir = lilv_path_canonical(dir); char* const path = lilv_path_join(abs_dir, filename); FILE* fd = fopen(path, "w"); if (!fd) { @@ -1243,36 +1252,34 @@ lilv_state_save(LilvWorld* world, lilv_state_make_links(state, abs_dir); // Write state to Turtle file - SerdNode file = serd_node_new_file_uri(USTR(path), NULL, NULL, true); - SerdNode node = uri ? serd_node_from_string(SERD_URI, USTR(uri)) : file; - SerdEnv* env = NULL; - SerdWriter* ttl = ttl_file_writer(fd, &file, &env); - int ret = - lilv_state_write(world, map, unmap, state, ttl, (const char*)node.buf, dir); + SerdNode* file = + serd_new_file_uri(SERD_MEASURE_STRING(path), SERD_EMPTY_STRING()); + SerdNode* node = + uri ? serd_new_uri(SERD_MEASURE_STRING(uri)) : serd_node_copy(file); + SerdEnv* env = NULL; + SerdWriter* ttl = ttl_file_writer(world->world, fd, file, &env); + SerdStatus st = lilv_state_write( + world, map, unmap, state, env, ttl, serd_node_string(node), dir); // Set saved dir and uri (FIXME: const violation) free(state->dir); lilv_node_free(state->uri); - ((LilvState*)state)->dir = lilv_strdup(abs_dir); - ((LilvState*)state)->uri = lilv_new_uri(world, (const char*)node.buf); + ((LilvState*)state)->dir = lilv_path_join(abs_dir, NULL); + ((LilvState*)state)->uri = node; - serd_node_free(&file); + serd_node_free(file); serd_writer_free(ttl); serd_env_free(env); fclose(fd); // Add entry to manifest - if (!ret) { - char* const manifest = lilv_path_join(abs_dir, "manifest.ttl"); - - ret = add_state_to_manifest(world, state->plugin_uri, manifest, uri, path); - - free(manifest); - } + char* const manifest = lilv_path_join(abs_dir, "manifest.ttl"); + add_state_to_manifest(world, state->plugin_uri, manifest, uri, path); + free(manifest); free(abs_dir); free(path); - return ret; + return st; } char* @@ -1288,16 +1295,18 @@ lilv_state_to_string(LilvWorld* world, return NULL; } - SerdChunk chunk = {NULL, 0}; - SerdEnv* env = NULL; - SerdNode base = serd_node_from_string(SERD_URI, USTR(base_uri)); - SerdWriter* writer = ttl_writer(serd_chunk_sink, &chunk, &base, &env); + SerdBuffer buffer = {NULL, 0}; + SerdEnv* env = NULL; + SerdNode* base = serd_new_uri(SERD_MEASURE_STRING(base_uri)); + SerdByteSink* sink = serd_byte_sink_new_buffer(&buffer); + SerdWriter* writer = ttl_writer(world->world, sink, base, &env); - lilv_state_write(world, map, unmap, state, writer, uri, NULL); + lilv_state_write(world, map, unmap, state, env, writer, uri, NULL); serd_writer_free(writer); + serd_byte_sink_free(sink); serd_env_free(env); - char* str = (char*)serd_chunk_sink_finish(&chunk); + char* str = serd_buffer_sink_finish(&buffer); char* result = lilv_strdup(str); serd_free(str); return result; @@ -1332,45 +1341,54 @@ lilv_state_delete(LilvWorld* world, const LilvState* state) } LilvNode* bundle = lilv_new_file_uri(world, NULL, state->dir); - LilvNode* manifest = lilv_world_get_manifest_uri(world, bundle); + LilvNode* manifest = lilv_world_get_manifest_node(world, bundle); char* manifest_path = get_canonical_path(manifest); const bool has_manifest = lilv_path_exists(manifest_path); - SordModel* model = sord_new(world->world, SORD_SPO, false); + SerdModel* model = serd_model_new(world->world, SERD_INDEX_SPO); if (has_manifest) { // Read manifest into temporary local model - SerdEnv* env = serd_env_new(sord_node_to_serd_node(manifest->node)); - SerdReader* ttl = sord_new_reader(model, env, SERD_TURTLE, NULL); - serd_reader_read_file(ttl, USTR(manifest_path)); - serd_reader_free(ttl); + SerdEnv* env = serd_env_new(serd_node_string_view(manifest)); + SerdSink* inserter = serd_inserter_new(model, NULL); + SerdReader* reader = serd_reader_new( + world->world, SERD_TURTLE, 0, env, inserter, LILV_READER_STACK_SIZE); + + SerdByteSource* source = + serd_byte_source_new_filename(manifest_path, PAGE_SIZE); + + serd_reader_start(reader, source); + serd_reader_read_document(reader); + serd_byte_source_free(source); + serd_reader_free(reader); serd_env_free(env); } if (state->uri) { - SordNode* file = - sord_get(model, state->uri->node, world->uris.rdfs_seeAlso, NULL, NULL); + const SerdNode* file = + serd_model_get(model, state->uri, world->uris.rdfs_seeAlso, NULL, NULL); if (file) { + char* const path = serd_parse_file_uri(serd_node_string(file), NULL); + char* const real_path = lilv_path_canonical(path); + // Remove state file - const uint8_t* uri = sord_node_get_string(file); - char* path = (char*)serd_file_uri_parse(uri, NULL); - char* real_path = lilv_path_canonical(path); - if (path) { + if (real_path) { try_unlink(state->dir, real_path); } + serd_free(real_path); serd_free(path); } // Remove any existing manifest entries for this state const char* state_uri_str = lilv_node_as_string(state->uri); - remove_manifest_entry(world->world, model, state_uri_str); - remove_manifest_entry(world->world, world->model, state_uri_str); + remove_manifest_entry(model, state_uri_str); + remove_manifest_entry(world->model, state_uri_str); } // Drop bundle from model lilv_world_unload_bundle(world, bundle); - if (sord_num_quads(model) == 0) { + if (serd_model_size(model) == 0) { // Manifest is empty, attempt to remove bundle entirely if (has_manifest) { try_unlink(state->dir, manifest_path); @@ -1403,15 +1421,17 @@ lilv_state_delete(LilvWorld* world, const LilvState* state) } } else { // Still something in the manifest, update and reload bundle - const SerdNode* manifest_node = sord_node_to_serd_node(manifest->node); - SerdEnv* env = serd_env_new(manifest_node); + SerdEnv* env = serd_env_new(serd_node_string_view(manifest)); + + if (write_manifest(world, env, model, manifest)) { + return 1; + } - write_manifest(world, env, model, manifest_node); lilv_world_load_bundle(world, bundle); serd_env_free(env); } - sord_free(model); + serd_model_free(model); lilv_free(manifest_path); lilv_node_free(manifest); lilv_node_free(bundle); @@ -27,8 +27,6 @@ #include <errno.h> #include <stdarg.h> #include <stdbool.h> -#include <stddef.h> -#include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <string.h> @@ -87,12 +85,6 @@ lilv_strdup(const char* str) return copy; } -char* -lilv_file_uri_parse(const char* uri, char** hostname) -{ - return (char*)serd_file_uri_parse((const uint8_t*)uri, (uint8_t**)hostname); -} - /** Return the current LANG converted to Turtle (i.e. RFC3066) style. * For example, if LANG is set to "en_CA.utf-8", this returns "en-ca". */ diff --git a/src/world.c b/src/world.c index 47dc147..31fa906 100644 --- a/src/world.c +++ b/src/world.c @@ -19,14 +19,13 @@ #include "lilv_internal.h" #include "lilv/lilv.h" +#include "lv2/core/lv2.h" +#include "lv2/presets/presets.h" +#include "lv2/state/state.h" #include "serd/serd.h" -#include "sord/sord.h" #include "zix/common.h" #include "zix/tree.h" -#include "lv2/core/lv2.h" -#include "lv2/presets/presets.h" - #ifdef LILV_DYN_MANIFEST # include "lv2/dynmanifest/dynmanifest.h" # include <dlfcn.h> @@ -34,25 +33,25 @@ #include <assert.h> #include <stdbool.h> -#include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <string.h> static int -lilv_world_drop_graph(LilvWorld* world, const SordNode* graph); +lilv_world_drop_graph(LilvWorld* world, const SerdNode* graph); LilvWorld* lilv_world_new(void) { LilvWorld* world = (LilvWorld*)calloc(1, sizeof(LilvWorld)); - world->world = sord_world_new(); + world->world = serd_world_new(); if (!world->world) { goto fail; } - world->model = sord_new(world->world, SORD_SPO | SORD_OPS, true); + world->model = serd_model_new( + world->world, SERD_INDEX_SPO | SERD_INDEX_OPS | SERD_INDEX_GRAPHS); if (!world->model) { goto fail; } @@ -70,7 +69,7 @@ lilv_world_new(void) #define NS_DYNMAN "http://lv2plug.in/ns/ext/dynmanifest#" #define NS_OWL "http://www.w3.org/2002/07/owl#" -#define NEW_URI(uri) sord_new_uri(world->world, (const uint8_t*)(uri)) +#define NEW_URI(uri) serd_new_uri(SERD_STATIC_STRING(uri)) world->uris.dc_replaces = NEW_URI(NS_DCTERMS "replaces"); world->uris.dman_DynManifest = NEW_URI(NS_DYNMAN "DynManifest"); @@ -94,9 +93,11 @@ lilv_world_new(void) world->uris.lv2_portProperty = NEW_URI(LV2_CORE__portProperty); world->uris.lv2_reportsLatency = NEW_URI(LV2_CORE__reportsLatency); world->uris.lv2_requiredFeature = NEW_URI(LV2_CORE__requiredFeature); - world->uris.lv2_symbol = NEW_URI(LV2_CORE__symbol); + world->uris.lv2_project = NEW_URI(LV2_CORE__project); world->uris.lv2_prototype = NEW_URI(LV2_CORE__prototype); + world->uris.lv2_symbol = NEW_URI(LV2_CORE__symbol); world->uris.owl_Ontology = NEW_URI(NS_OWL "Ontology"); + world->uris.pset_Preset = NEW_URI(LV2_PRESETS__Preset); world->uris.pset_value = NEW_URI(LV2_PRESETS__value); world->uris.rdf_a = NEW_URI(LILV_NS_RDF "type"); world->uris.rdf_value = NEW_URI(LILV_NS_RDF "value"); @@ -104,10 +105,12 @@ lilv_world_new(void) world->uris.rdfs_label = NEW_URI(LILV_NS_RDFS "label"); world->uris.rdfs_seeAlso = NEW_URI(LILV_NS_RDFS "seeAlso"); world->uris.rdfs_subClassOf = NEW_URI(LILV_NS_RDFS "subClassOf"); + world->uris.state_state = NEW_URI(LV2_STATE__state); world->uris.xsd_base64Binary = NEW_URI(LILV_NS_XSD "base64Binary"); world->uris.xsd_boolean = NEW_URI(LILV_NS_XSD "boolean"); world->uris.xsd_decimal = NEW_URI(LILV_NS_XSD "decimal"); world->uris.xsd_double = NEW_URI(LILV_NS_XSD "double"); + world->uris.xsd_int = NEW_URI(LILV_NS_XSD "int"); world->uris.xsd_integer = NEW_URI(LILV_NS_XSD "integer"); world->uris.null_uri = NULL; @@ -136,14 +139,14 @@ lilv_world_free(LilvWorld* world) lilv_plugin_class_free(world->lv2_plugin_class); world->lv2_plugin_class = NULL; - for (SordNode** n = (SordNode**)&world->uris; *n; ++n) { - sord_node_free(world->world, *n); + for (SerdNode** n = (SerdNode**)&world->uris; *n; ++n) { + serd_node_free(*n); } for (LilvSpec* spec = world->specs; spec;) { LilvSpec* next = spec->next; - sord_node_free(world->world, spec->spec); - sord_node_free(world->world, spec->bundle); + serd_node_free(spec->spec); + serd_node_free(spec->bundle); lilv_nodes_free(spec->data_uris); free(spec); spec = next; @@ -173,10 +176,10 @@ lilv_world_free(LilvWorld* world) zix_tree_free((ZixTree*)world->plugin_classes); world->plugin_classes = NULL; - sord_free(world->model); + serd_model_free(world->model); world->model = NULL; - sord_world_free(world->world); + serd_world_free(world->world); world->world = NULL; free(world->opt.lv2_path); @@ -212,31 +215,20 @@ lilv_world_find_nodes(LilvWorld* world, const LilvNode* object) { if (subject && !lilv_node_is_uri(subject) && !lilv_node_is_blank(subject)) { - LILV_ERRORF("Subject `%s' is not a resource\n", - sord_node_get_string(subject->node)); + LILV_ERRORF("Subject `%s' is not a resource\n", serd_node_string(subject)); return NULL; - } - - if (!predicate) { + } else if (!predicate) { LILV_ERROR("Missing required predicate\n"); return NULL; - } - - if (!lilv_node_is_uri(predicate)) { - LILV_ERRORF("Predicate `%s' is not a URI\n", - sord_node_get_string(predicate->node)); + } else if (!lilv_node_is_uri(predicate)) { + LILV_ERRORF("Predicate `%s' is not a URI\n", serd_node_string(predicate)); return NULL; - } - - if (!subject && !object) { + } else if (!subject && !object) { LILV_ERROR("Both subject and object are NULL\n"); return NULL; } - return lilv_world_find_nodes_internal(world, - subject ? subject->node : NULL, - predicate->node, - object ? object->node : NULL); + return lilv_world_find_nodes_internal(world, subject, predicate, object); } LilvNode* @@ -245,52 +237,8 @@ lilv_world_get(LilvWorld* world, const LilvNode* predicate, const LilvNode* object) { - if (!object) { - // TODO: Improve performance (see lilv_plugin_get_one) - SordIter* stream = sord_search(world->model, - subject ? subject->node : NULL, - predicate ? predicate->node : NULL, - NULL, - NULL); - - LilvNodes* nodes = - lilv_nodes_from_stream_objects(world, stream, SORD_OBJECT); - - if (nodes) { - LilvNode* value = lilv_node_duplicate(lilv_nodes_get_first(nodes)); - lilv_nodes_free(nodes); - return value; - } - - return NULL; - } - - SordNode* snode = sord_get(world->model, - subject ? subject->node : NULL, - predicate ? predicate->node : NULL, - object ? object->node : NULL, - NULL); - LilvNode* lnode = lilv_node_new_from_node(world, snode); - sord_node_free(world->world, snode); - return lnode; -} - -SordIter* -lilv_world_query_internal(LilvWorld* world, - const SordNode* subject, - const SordNode* predicate, - const SordNode* object) -{ - return sord_search(world->model, subject, predicate, object, NULL); -} - -bool -lilv_world_ask_internal(LilvWorld* world, - const SordNode* subject, - const SordNode* predicate, - const SordNode* object) -{ - return sord_ask(world->model, subject, predicate, object, NULL); + return serd_node_copy( + serd_model_get(world->model, subject, predicate, object, NULL)); } bool @@ -299,59 +247,44 @@ lilv_world_ask(LilvWorld* world, const LilvNode* predicate, const LilvNode* object) { - return sord_ask(world->model, - subject ? subject->node : NULL, - predicate ? predicate->node : NULL, - object ? object->node : NULL, - NULL); + return serd_model_ask(world->model, subject, predicate, object, NULL); } -SordModel* +SerdModel* lilv_world_filter_model(LilvWorld* world, - SordModel* model, - const SordNode* subject, - const SordNode* predicate, - const SordNode* object, - const SordNode* graph) + SerdModel* model, + const SerdNode* subject, + const SerdNode* predicate, + const SerdNode* object, + const SerdNode* graph) { - SordModel* results = sord_new(world->world, SORD_SPO, false); - SordIter* i = sord_search(model, subject, predicate, object, graph); - for (; !sord_iter_end(i); sord_iter_next(i)) { - SordQuad quad; - sord_iter_get(i, quad); - sord_add(results, quad); + SerdModel* results = serd_model_new(world->world, SERD_INDEX_SPO); + SerdRange* r = serd_model_range(model, subject, predicate, object, graph); + for (; !serd_range_empty(r); serd_range_next(r)) { + serd_model_insert(results, serd_range_front(r)); } - sord_iter_free(i); + serd_range_free(r); return results; } LilvNodes* lilv_world_find_nodes_internal(LilvWorld* world, - const SordNode* subject, - const SordNode* predicate, - const SordNode* object) + const SerdNode* subject, + const SerdNode* predicate, + const SerdNode* object) { - return lilv_nodes_from_stream_objects( + return lilv_nodes_from_range( world, - lilv_world_query_internal(world, subject, predicate, object), - (object == NULL) ? SORD_OBJECT : SORD_SUBJECT); -} - -static SerdNode -lilv_new_uri_relative_to_base(const uint8_t* uri_str, - const uint8_t* base_uri_str) -{ - SerdURI base_uri; - serd_uri_parse(base_uri_str, &base_uri); - return serd_node_new_uri_from_string(uri_str, &base_uri, NULL); + serd_model_range(world->model, subject, predicate, object, NULL), + (object == NULL) ? SERD_OBJECT : SERD_SUBJECT); } -const uint8_t* +const char* lilv_world_blank_node_prefix(LilvWorld* world) { static char str[32]; snprintf(str, sizeof(str), "%u", world->n_read_files++); - return (const uint8_t*)str; + return str; } /** Comparator for sequences (e.g. world->plugins). */ @@ -411,24 +344,21 @@ lilv_collection_get_by_uri(const ZixTree* seq, const LilvNode* uri) static void lilv_world_add_spec(LilvWorld* world, - const SordNode* specification_node, - const SordNode* bundle_node) + const SerdNode* specification_node, + const SerdNode* bundle_node) { LilvSpec* spec = (LilvSpec*)malloc(sizeof(LilvSpec)); - spec->spec = sord_node_copy(specification_node); - spec->bundle = sord_node_copy(bundle_node); + spec->spec = serd_node_copy(specification_node); + spec->bundle = serd_node_copy(bundle_node); spec->data_uris = lilv_nodes_new(); // Add all data files (rdfs:seeAlso) - SordIter* files = sord_search( - world->model, specification_node, world->uris.rdfs_seeAlso, NULL, NULL); - FOREACH_MATCH (files) { - const SordNode* file_node = sord_iter_get_node(files, SORD_OBJECT); - zix_tree_insert((ZixTree*)spec->data_uris, - lilv_node_new_from_node(world, file_node), - NULL); + FOREACH_PAT( + s, world->model, specification_node, world->uris.rdfs_seeAlso, NULL, NULL) + { + const SerdNode* file_node = serd_statement_object(s); + zix_tree_insert((ZixTree*)spec->data_uris, serd_node_copy(file_node), NULL); } - sord_iter_free(files); // Add specification to world specification list spec->next = world->specs; @@ -437,15 +367,12 @@ lilv_world_add_spec(LilvWorld* world, static void lilv_world_add_plugin(LilvWorld* world, - const SordNode* plugin_node, + const SerdNode* plugin_uri, const LilvNode* manifest_uri, void* dynmanifest, - const SordNode* bundle) + const SerdNode* bundle) { - (void)dynmanifest; - - LilvNode* plugin_uri = lilv_node_new_from_node(world, plugin_node); - ZixTreeIter* z = NULL; + ZixTreeIter* z = NULL; LilvPlugin* plugin = (LilvPlugin*)lilv_plugins_get_by_uri(world->plugins, plugin_uri); @@ -454,15 +381,13 @@ lilv_world_add_plugin(LilvWorld* world, // (use the first plugin found in LV2_PATH) const LilvNode* last_bundle = lilv_plugin_get_bundle_uri(plugin); const char* plugin_uri_str = lilv_node_as_uri(plugin_uri); - if (sord_node_equals(bundle, last_bundle->node)) { + if (serd_node_equals(bundle, last_bundle)) { LILV_WARNF("Reloading plugin <%s>\n", plugin_uri_str); plugin->loaded = false; - lilv_node_free(plugin_uri); } else { LILV_WARNF("Duplicate plugin <%s>\n", plugin_uri_str); LILV_WARNF("... found in %s\n", lilv_node_as_string(last_bundle)); - LILV_WARNF("... and %s (ignored)\n", sord_node_get_string(bundle)); - lilv_node_free(plugin_uri); + LILV_WARNF("... and %s (ignored)\n", serd_node_string(bundle)); return; } } else if ((z = lilv_collection_find_by_uri((const ZixTree*)world->zombies, @@ -471,12 +396,10 @@ lilv_world_add_plugin(LilvWorld* world, plugin = (LilvPlugin*)zix_tree_get(z); zix_tree_remove((ZixTree*)world->zombies, z); zix_tree_insert((ZixTree*)world->plugins, plugin, NULL); - lilv_node_free(plugin_uri); - lilv_plugin_clear(plugin, lilv_node_new_from_node(world, bundle)); + lilv_plugin_clear(plugin, bundle); } else { // Add new plugin to the world - plugin = lilv_plugin_new( - world, plugin_uri, lilv_node_new_from_node(world, bundle)); + plugin = lilv_plugin_new(world, plugin_uri, bundle); // Add manifest as plugin data file (as if it were rdfs:seeAlso) zix_tree_insert( @@ -492,37 +415,40 @@ lilv_world_add_plugin(LilvWorld* world, plugin->dynmanifest = (LilvDynManifest*)dynmanifest; ++((LilvDynManifest*)dynmanifest)->refs; } +#else + (void)dynmanifest; #endif // Add all plugin data files (rdfs:seeAlso) - SordIter* files = sord_search( - world->model, plugin_node, world->uris.rdfs_seeAlso, NULL, NULL); - FOREACH_MATCH (files) { - const SordNode* file_node = sord_iter_get_node(files, SORD_OBJECT); - zix_tree_insert((ZixTree*)plugin->data_uris, - lilv_node_new_from_node(world, file_node), - NULL); + FOREACH_PAT(s, world->model, plugin_uri, world->uris.rdfs_seeAlso, NULL, NULL) + { + const SerdNode* file_node = serd_statement_object(s); + zix_tree_insert( + (ZixTree*)plugin->data_uris, serd_node_copy(file_node), NULL); } - sord_iter_free(files); } SerdStatus -lilv_world_load_graph(LilvWorld* world, SordNode* graph, const LilvNode* uri) +lilv_world_load_graph(LilvWorld* world, + const SerdNode* graph, + const LilvNode* uri) { - const SerdNode* base = sord_node_to_serd_node(uri->node); - SerdEnv* env = serd_env_new(base); - SerdReader* reader = sord_new_reader(world->model, env, SERD_TURTLE, graph); + SerdEnv* env = serd_env_new(serd_node_string_view(uri)); + SerdSink* inserter = serd_inserter_new(world->model, graph); + SerdReader* reader = serd_reader_new( + world->world, SERD_TURTLE, 0, env, inserter, LILV_READER_STACK_SIZE); const SerdStatus st = lilv_world_load_file(world, reader, uri); - serd_env_free(env); serd_reader_free(reader); + serd_sink_free(inserter); + serd_env_free(env); return st; } static void lilv_world_load_dyn_manifest(LilvWorld* world, - SordNode* bundle_node, + const SerdNode* bundle_node, const LilvNode* manifest) { #ifdef LILV_DYN_MANIFEST @@ -533,33 +459,33 @@ lilv_world_load_dyn_manifest(LilvWorld* world, LV2_Dyn_Manifest_Handle handle = NULL; // ?dman a dynman:DynManifest bundle_node - SordModel* model = lilv_world_filter_model(world, + SerdModel* model = lilv_world_filter_model(world, world->model, NULL, world->uris.rdf_a, world->uris.dman_DynManifest, bundle_node); - SordIter* iter = sord_begin(model); - for (; !sord_iter_end(iter); sord_iter_next(iter)) { - const SordNode* dmanifest = sord_iter_get_node(iter, SORD_SUBJECT); + SerdIter* iter = serd_begin(model); + for (; !serd_iter_end(iter); serd_iter_next(iter)) { + const SerdNode* dmanifest = serd_iter_get_node(iter, SERD_SUBJECT); // ?dman lv2:binary ?binary - SordIter* binaries = sord_search( + SerdIter* binaries = serd_model_find( world->model, dmanifest, world->uris.lv2_binary, NULL, bundle_node); - if (sord_iter_end(binaries)) { - sord_iter_free(binaries); + if (serd_iter_end(binaries)) { + serd_iter_free(binaries); LILV_ERRORF("Dynamic manifest in <%s> has no binaries, ignored\n", - sord_node_get_string(bundle_node)); + serd_node_string(bundle_node)); continue; } // Get binary path - const SordNode* binary = sord_iter_get_node(binaries, SORD_OBJECT); - const uint8_t* lib_uri = sord_node_get_string(binary); - char* lib_path = lilv_file_uri_parse((const char*)lib_uri, 0); + const SerdNode* const binary = serd_iter_get_node(binaries, SERD_OBJECT); + const char* const lib_uri = serd_node_string(binary); + char* const lib_path = serd_file_uri_parse(lib_uri, 0); if (!lib_path) { LILV_ERROR("No dynamic manifest library path\n"); - sord_iter_free(binaries); + serd_iter_free(binaries); continue; } @@ -569,7 +495,7 @@ lilv_world_load_dyn_manifest(LilvWorld* world, if (!lib) { LILV_ERRORF( "Failed to open dynmanifest library `%s' (%s)\n", lib_path, dlerror()); - sord_iter_free(binaries); + serd_iter_free(binaries); lilv_free(lib_path); continue; } @@ -580,7 +506,7 @@ lilv_world_load_dyn_manifest(LilvWorld* world, OpenFunc dmopen = (OpenFunc)lilv_dlfunc(lib, "lv2_dyn_manifest_open"); if (!dmopen || dmopen(&handle, &dman_features)) { LILV_ERRORF("No `lv2_dyn_manifest_open' in `%s'\n", lib_path); - sord_iter_free(binaries); + serd_iter_free(binaries); dlclose(lib); lilv_free(lib_path); continue; @@ -592,19 +518,19 @@ lilv_world_load_dyn_manifest(LilvWorld* world, (GetSubjectsFunc)lilv_dlfunc(lib, "lv2_dyn_manifest_get_subjects"); if (!get_subjects_func) { LILV_ERRORF("No `lv2_dyn_manifest_get_subjects' in `%s'\n", lib_path); - sord_iter_free(binaries); + serd_iter_free(binaries); dlclose(lib); lilv_free(lib_path); continue; } LilvDynManifest* desc = (LilvDynManifest*)malloc(sizeof(LilvDynManifest)); - desc->bundle = lilv_node_new_from_node(world, bundle_node); + desc->bundle = serd_node_copy(bundle_node); desc->lib = lib; desc->handle = handle; desc->refs = 0; - sord_iter_free(binaries); + serd_iter_free(binaries); // Generate data file FILE* fd = tmpfile(); @@ -613,12 +539,12 @@ lilv_world_load_dyn_manifest(LilvWorld* world, // Parse generated data file into temporary model // FIXME - const SerdNode* base = sord_node_to_serd_node(dmanifest); + const SerdNode* base = dmanifest; SerdEnv* env = serd_env_new(base); - SerdReader* reader = sord_new_reader( - world->model, env, SERD_TURTLE, sord_node_copy(dmanifest)); + SerdReader* reader = serd_model_new_reader( + world->model, env, SERD_TURTLE, serd_node_copy(dmanifest)); serd_reader_add_blank_prefix(reader, lilv_world_blank_node_prefix(world)); - serd_reader_read_file_handle(reader, fd, (const uint8_t*)"(dyn-manifest)"); + serd_reader_read_file_handle(reader, fd, "(dyn-manifest)"); serd_reader_free(reader); serd_env_free(env); @@ -626,32 +552,32 @@ lilv_world_load_dyn_manifest(LilvWorld* world, fclose(fd); // ?plugin a lv2:Plugin - SordModel* plugins = lilv_world_filter_model(world, + SerdModel* plugins = lilv_world_filter_model(world, world->model, NULL, world->uris.rdf_a, world->uris.lv2_Plugin, dmanifest); - SordIter* p = sord_begin(plugins); - FOREACH_MATCH (p) { - const SordNode* plug = sord_iter_get_node(p, SORD_SUBJECT); + SerdIter* p = serd_begin(plugins); + FOREACH_MATCH (s, p) { + const SerdNode* plug = serd_statement_subject(s); lilv_world_add_plugin(world, plug, manifest, desc, bundle_node); } if (desc->refs == 0) { - lilv_dynmanifest_free(desc); + free(desc); } - sord_iter_free(p); - sord_free(plugins); + serd_iter_free(p); + serd_free(plugins); lilv_free(lib_path); } - sord_iter_free(iter); - sord_free(model); + serd_iter_free(iter); + serd_free(model); -#else // LILV_DYN_MANIFEST +#else (void)world; (void)bundle_node; (void)manifest; -#endif +#endif // LILV_DYN_MANIFEST } #ifdef LILV_DYN_MANIFEST @@ -672,67 +598,88 @@ lilv_dynmanifest_free(LilvDynManifest* dynmanifest) #endif // LILV_DYN_MANIFEST LilvNode* -lilv_world_get_manifest_uri(LilvWorld* world, const LilvNode* bundle_uri) +lilv_world_get_manifest_node(LilvWorld* world, const LilvNode* bundle_node) { - SerdNode manifest_uri = lilv_new_uri_relative_to_base( - (const uint8_t*)"manifest.ttl", sord_node_get_string(bundle_uri->node)); - LilvNode* manifest = lilv_new_uri(world, (const char*)manifest_uri.buf); - serd_node_free(&manifest_uri); - return manifest; + (void)world; + + const SerdURIView bundle_uri = serd_node_uri_view(bundle_node); + const SerdURIView manifest_ref = serd_parse_uri("manifest.ttl"); + const SerdURIView manifest_uri = serd_resolve_uri(manifest_ref, bundle_uri); + + return serd_new_parsed_uri(manifest_uri); +} + +char* +lilv_world_get_manifest_path(LilvWorld* world, const LilvNode* bundle_node) +{ + const SerdNode* const node = lilv_world_get_manifest_node(world, bundle_node); + + return serd_parse_file_uri(serd_node_string(node), NULL); } -static SordModel* +static SerdModel* load_plugin_model(LilvWorld* world, const LilvNode* bundle_uri, const LilvNode* plugin_uri) { // Create model and reader for loading into it - SordNode* bundle_node = bundle_uri->node; - SordModel* model = sord_new(world->world, SORD_SPO | SORD_OPS, false); - SerdEnv* env = serd_env_new(sord_node_to_serd_node(bundle_node)); - SerdReader* reader = sord_new_reader(model, env, SERD_TURTLE, NULL); + SerdModel* model = + serd_model_new(world->world, SERD_INDEX_SPO | SERD_INDEX_OPS); + SerdEnv* env = serd_env_new(serd_node_string_view(bundle_uri)); + SerdSink* inserter = serd_inserter_new(model, NULL); + SerdReader* reader = serd_reader_new( + world->world, SERD_TURTLE, 0, env, inserter, LILV_READER_STACK_SIZE); // Load manifest - LilvNode* manifest_uri = lilv_world_get_manifest_uri(world, bundle_uri); + char* manifest_path = lilv_world_get_manifest_path(world, bundle_uri); + SerdByteSource* manifest_source = + serd_byte_source_new_filename(manifest_path, 4096); serd_reader_add_blank_prefix(reader, lilv_world_blank_node_prefix(world)); - serd_reader_read_file(reader, - (const uint8_t*)lilv_node_as_string(manifest_uri)); + serd_reader_start(reader, manifest_source); + serd_reader_read_document(reader); + serd_reader_finish(reader); // Load any seeAlso files - SordModel* files = lilv_world_filter_model( - world, model, plugin_uri->node, world->uris.rdfs_seeAlso, NULL, NULL); - - SordIter* f = sord_begin(files); - FOREACH_MATCH (f) { - const SordNode* file = sord_iter_get_node(f, SORD_OBJECT); - const uint8_t* file_str = sord_node_get_string(file); - if (sord_node_get_type(file) == SORD_URI) { + SerdModel* files = lilv_world_filter_model( + world, model, plugin_uri, world->uris.rdfs_seeAlso, NULL, NULL); + + SerdIter* f = serd_model_begin(files); + for (; !serd_iter_equals(f, serd_model_end(files)); serd_iter_next(f)) { + const SerdNode* file = serd_statement_object(serd_iter_get(f)); + const char* uri_str = serd_node_string(file); + if (serd_node_type(file) == SERD_URI) { + char* path_str = serd_parse_file_uri(uri_str, NULL); + SerdByteSource* source = serd_byte_source_new_filename(path_str, 4096); + serd_reader_add_blank_prefix(reader, lilv_world_blank_node_prefix(world)); - serd_reader_read_file(reader, file_str); + serd_reader_start(reader, source); + serd_reader_read_document(reader); + serd_reader_finish(reader); + + serd_byte_source_free(source); } } - sord_iter_free(f); - sord_free(files); + serd_iter_free(f); + serd_model_free(files); serd_reader_free(reader); serd_env_free(env); - lilv_node_free(manifest_uri); return model; } static LilvVersion -get_version(LilvWorld* world, SordModel* model, const LilvNode* subject) +get_version(LilvWorld* world, SerdModel* model, const LilvNode* subject) { - const SordNode* minor_node = - sord_get(model, subject->node, world->uris.lv2_minorVersion, NULL, NULL); - const SordNode* micro_node = - sord_get(model, subject->node, world->uris.lv2_microVersion, NULL, NULL); + const SerdNode* minor_node = + serd_model_get(model, subject, world->uris.lv2_minorVersion, NULL, NULL); + const SerdNode* micro_node = + serd_model_get(model, subject, world->uris.lv2_microVersion, NULL, NULL); LilvVersion version = {0, 0}; if (minor_node && micro_node) { - version.minor = atoi((const char*)sord_node_get_string(minor_node)); - version.micro = atoi((const char*)sord_node_get_string(micro_node)); + version.minor = atoi(serd_node_string(minor_node)); + version.micro = atoi(serd_node_string(micro_node)); } return version; @@ -742,16 +689,14 @@ void lilv_world_load_bundle(LilvWorld* world, const LilvNode* bundle_uri) { if (!lilv_node_is_uri(bundle_uri)) { - LILV_ERRORF("Bundle URI `%s' is not a URI\n", - sord_node_get_string(bundle_uri->node)); + LILV_ERRORF("Bundle URI `%s' is not a URI\n", serd_node_string(bundle_uri)); return; } - SordNode* bundle_node = bundle_uri->node; - LilvNode* manifest = lilv_world_get_manifest_uri(world, bundle_uri); + LilvNode* manifest = lilv_world_get_manifest_node(world, bundle_uri); - // Read manifest into model with graph = bundle_node - SerdStatus st = lilv_world_load_graph(world, bundle_node, manifest); + // Read manifest into model with graph = bundle_uri + SerdStatus st = lilv_world_load_graph(world, bundle_uri, manifest); if (st > SERD_FAILURE) { LILV_ERRORF("Error reading %s\n", lilv_node_as_string(manifest)); lilv_node_free(manifest); @@ -759,32 +704,32 @@ lilv_world_load_bundle(LilvWorld* world, const LilvNode* bundle_uri) } // ?plugin a lv2:Plugin - SordIter* plug_results = sord_search( - world->model, NULL, world->uris.rdf_a, world->uris.lv2_Plugin, bundle_node); + SerdRange* plug_results = serd_model_range( + world->model, NULL, world->uris.rdf_a, world->uris.lv2_Plugin, bundle_uri); // Find any loaded plugins that will be replaced with a newer version LilvNodes* unload_uris = lilv_nodes_new(); - FOREACH_MATCH (plug_results) { - const SordNode* plug = sord_iter_get_node(plug_results, SORD_SUBJECT); + FOREACH_MATCH (s, plug_results) { + const SerdNode* plug = serd_statement_subject(s); - LilvNode* plugin_uri = lilv_node_new_from_node(world, plug); + LilvNode* plugin_uri = serd_node_copy(plug); const LilvPlugin* plugin = lilv_plugins_get_by_uri(world->plugins, plugin_uri); const LilvNode* last_bundle = plugin ? lilv_plugin_get_bundle_uri(plugin) : NULL; - if (!plugin || sord_node_equals(bundle_node, last_bundle->node)) { + if (!plugin || serd_node_equals(bundle_uri, last_bundle)) { // No previously loaded version, or it's from the same bundle lilv_node_free(plugin_uri); continue; } // Compare versions - SordModel* this_model = load_plugin_model(world, bundle_uri, plugin_uri); + SerdModel* this_model = load_plugin_model(world, bundle_uri, plugin_uri); LilvVersion this_version = get_version(world, this_model, plugin_uri); - SordModel* last_model = load_plugin_model(world, last_bundle, plugin_uri); + SerdModel* last_model = load_plugin_model(world, last_bundle, plugin_uri); LilvVersion last_version = get_version(world, last_model, plugin_uri); - sord_free(this_model); - sord_free(last_model); + serd_model_free(this_model); + serd_model_free(last_model); const int cmp = lilv_version_cmp(&this_version, &last_version); if (cmp > 0) { zix_tree_insert( @@ -792,20 +737,20 @@ lilv_world_load_bundle(LilvWorld* world, const LilvNode* bundle_uri) LILV_WARNF("Replacing version %d.%d of <%s> from <%s>\n", last_version.minor, last_version.micro, - sord_node_get_string(plug), - sord_node_get_string(last_bundle->node)); + serd_node_string(plug), + serd_node_string(last_bundle)); LILV_NOTEF("New version %d.%d found in <%s>\n", this_version.minor, this_version.micro, - sord_node_get_string(bundle_node)); + serd_node_string(bundle_uri)); } else if (cmp < 0) { - LILV_WARNF("Ignoring bundle <%s>\n", sord_node_get_string(bundle_node)); + LILV_WARNF("Ignoring bundle <%s>\n", serd_node_string(bundle_uri)); LILV_NOTEF("Newer version of <%s> loaded from <%s>\n", - sord_node_get_string(plug), - sord_node_get_string(last_bundle->node)); + serd_node_string(plug), + serd_node_string(last_bundle)); lilv_node_free(plugin_uri); - sord_iter_free(plug_results); - lilv_world_drop_graph(world, bundle_node); + serd_range_free(plug_results); + lilv_world_drop_graph(world, bundle_uri); lilv_node_free(manifest); lilv_nodes_free(unload_uris); return; @@ -813,7 +758,7 @@ lilv_world_load_bundle(LilvWorld* world, const LilvNode* bundle_uri) lilv_node_free(plugin_uri); } - sord_iter_free(plug_results); + serd_range_free(plug_results); // Unload any old conflicting plugins LilvNodes* unload_bundles = lilv_nodes_new(); @@ -837,49 +782,46 @@ lilv_world_load_bundle(LilvWorld* world, const LilvNode* bundle_uri) lilv_nodes_free(unload_bundles); // Re-search for plugin results now that old plugins are gone - plug_results = sord_search( - world->model, NULL, world->uris.rdf_a, world->uris.lv2_Plugin, bundle_node); + plug_results = serd_model_range( + world->model, NULL, world->uris.rdf_a, world->uris.lv2_Plugin, bundle_uri); - FOREACH_MATCH (plug_results) { - const SordNode* plug = sord_iter_get_node(plug_results, SORD_SUBJECT); - lilv_world_add_plugin(world, plug, manifest, NULL, bundle_node); + FOREACH_MATCH (s, plug_results) { + const SerdNode* plug = serd_statement_subject(s); + lilv_world_add_plugin(world, plug, manifest, NULL, bundle_uri); } - sord_iter_free(plug_results); + serd_range_free(plug_results); - lilv_world_load_dyn_manifest(world, bundle_node, manifest); + lilv_world_load_dyn_manifest(world, bundle_uri, manifest); // ?spec a lv2:Specification // ?spec a owl:Ontology - const SordNode* spec_preds[] = { + const SerdNode* spec_preds[] = { world->uris.lv2_Specification, world->uris.owl_Ontology, NULL}; - for (const SordNode** p = spec_preds; *p; ++p) { - SordIter* i = - sord_search(world->model, NULL, world->uris.rdf_a, *p, bundle_node); - FOREACH_MATCH (i) { - const SordNode* spec = sord_iter_get_node(i, SORD_SUBJECT); - lilv_world_add_spec(world, spec, bundle_node); + for (const SerdNode** p = spec_preds; *p; ++p) { + FOREACH_PAT(s, world->model, NULL, world->uris.rdf_a, *p, bundle_uri) + { + const SerdNode* spec = serd_statement_subject(s); + lilv_world_add_spec(world, spec, bundle_uri); } - sord_iter_free(i); } lilv_node_free(manifest); } static int -lilv_world_drop_graph(LilvWorld* world, const SordNode* graph) +lilv_world_drop_graph(LilvWorld* world, const SerdNode* graph) { - SordIter* i = sord_search(world->model, NULL, NULL, NULL, graph); - while (!sord_iter_end(i)) { - const SerdStatus st = sord_erase(world->model, i); - if (st) { - LILV_ERRORF("Error removing statement from <%s> (%s)\n", - sord_node_get_string(graph), - serd_strerror(st)); - return st; - } + SerdRange* r = serd_model_range(world->model, NULL, NULL, NULL, graph); + const SerdStatus st = serd_model_erase_range(world->model, r); + + if (st) { + LILV_ERRORF("Error dropping graph <%s> (%s)\n", + serd_node_string(graph), + serd_strerror(st)); + return st; } - sord_iter_free(i); + serd_range_free(r); return 0; } @@ -941,20 +883,25 @@ lilv_world_unload_bundle(LilvWorld* world, const LilvNode* bundle_uri) } // Drop everything in bundle graph - return lilv_world_drop_graph(world, bundle_uri->node); + return lilv_world_drop_graph(world, bundle_uri); } static void load_dir_entry(const char* dir, const char* name, void* data) { LilvWorld* world = (LilvWorld*)data; - char* path = lilv_strjoin(dir, "/", name, "/", NULL); - SerdNode suri = serd_node_new_file_uri((const uint8_t*)path, 0, 0, true); - LilvNode* node = lilv_new_uri(world, (const char*)suri.buf); + if (!strcmp(name, ".") || !strcmp(name, "..")) { + return; + } + + char* path = lilv_strjoin(dir, "/", name, "/", NULL); + SerdNode* suri = + serd_new_file_uri(SERD_MEASURE_STRING(path), SERD_EMPTY_STRING()); + LilvNode* node = lilv_new_uri(world, serd_node_string(suri)); lilv_world_load_bundle(world, node); lilv_node_free(node); - serd_node_free(&suri); + serd_node_free(suri); free(path); } @@ -1025,34 +972,29 @@ lilv_world_load_plugin_classes(LilvWorld* world) is e.g. how a host would build a menu), they won't be seen anyway... */ - SordIter* classes = sord_search( - world->model, NULL, world->uris.rdf_a, world->uris.rdfs_Class, NULL); - FOREACH_MATCH (classes) { - const SordNode* class_node = sord_iter_get_node(classes, SORD_SUBJECT); + FOREACH_PAT( + s, world->model, NULL, world->uris.rdf_a, world->uris.rdfs_Class, NULL) + { + const SerdNode* class_node = serd_statement_subject(s); - SordNode* parent = sord_get( + const SerdNode* parent = serd_model_get( world->model, class_node, world->uris.rdfs_subClassOf, NULL, NULL); - if (!parent || sord_node_get_type(parent) != SORD_URI) { + if (!parent || serd_node_type(parent) != SERD_URI) { continue; } - SordNode* label = - sord_get(world->model, class_node, world->uris.rdfs_label, NULL, NULL); + const SerdNode* label = serd_model_get( + world->model, class_node, world->uris.rdfs_label, NULL, NULL); if (!label) { - sord_node_free(world->world, parent); continue; } - LilvPluginClass* pclass = lilv_plugin_class_new( - world, parent, class_node, (const char*)sord_node_get_string(label)); + LilvPluginClass* pclass = + lilv_plugin_class_new(world, parent, class_node, serd_node_string(label)); if (pclass) { zix_tree_insert((ZixTree*)world->plugin_classes, pclass, NULL); } - - sord_node_free(world->world, label); - sord_node_free(world->world, parent); } - sord_iter_free(classes); } void @@ -1074,11 +1016,11 @@ lilv_world_load_all(LilvWorld* world) (const LilvPlugin*)lilv_collection_get((ZixTree*)world->plugins, p); // ?new dc:replaces plugin - if (sord_ask(world->model, - NULL, - world->uris.dc_replaces, - lilv_plugin_get_uri(plugin)->node, - NULL)) { + if (serd_model_ask(world->model, + NULL, + world->uris.dc_replaces, + lilv_plugin_get_uri(plugin), + NULL)) { // TODO: Check if replacement is a known plugin? (expensive) ((LilvPlugin*)plugin)->replaced = true; } @@ -1092,25 +1034,33 @@ lilv_world_load_all(LilvWorld* world) SerdStatus lilv_world_load_file(LilvWorld* world, SerdReader* reader, const LilvNode* uri) { - ZixTreeIter* iter = NULL; + ZixTreeIter* iter; if (!zix_tree_find((ZixTree*)world->loaded_files, uri, &iter)) { return SERD_FAILURE; // File has already been loaded } - size_t uri_len = 0; - const uint8_t* const uri_str = - sord_node_get_string_counted(uri->node, &uri_len); - if (strncmp((const char*)uri_str, "file:", 5)) { + const char* const uri_str = serd_node_string(uri); + const size_t uri_len = serd_node_length(uri); + if (strncmp(uri_str, "file:", 5)) { return SERD_FAILURE; // Not a local file + } else if (strcmp(uri_str + uri_len - 4, ".ttl")) { + return SERD_FAILURE; // Not a Turtle file } - if (strcmp((const char*)uri_str + uri_len - 4, ".ttl")) { - return SERD_FAILURE; // Not a Turtle file + SerdStatus st = SERD_SUCCESS; + char* hostname = NULL; + char* filename = serd_parse_file_uri(serd_node_string(uri), &hostname); + if (!filename || hostname) { + return SERD_ERR_BAD_ARG; } + SerdByteSource* const source = + serd_byte_source_new_filename(filename, PAGE_SIZE); + serd_reader_add_blank_prefix(reader, lilv_world_blank_node_prefix(world)); - const SerdStatus st = serd_reader_read_file(reader, uri_str); - if (st) { + if ((st = serd_reader_start(reader, source)) || + (st = serd_reader_read_document(reader)) || + (st = serd_reader_finish(reader))) { LILV_ERRORF("Error loading file `%s'\n", lilv_node_as_string(uri)); return st; } @@ -1124,30 +1074,29 @@ int lilv_world_load_resource(LilvWorld* world, const LilvNode* resource) { if (!lilv_node_is_uri(resource) && !lilv_node_is_blank(resource)) { - LILV_ERRORF("Node `%s' is not a resource\n", - sord_node_get_string(resource->node)); + LILV_ERRORF("Node `%s' is not a resource\n", serd_node_string(resource)); return -1; } - SordModel* files = lilv_world_filter_model( - world, world->model, resource->node, world->uris.rdfs_seeAlso, NULL, NULL); + SerdModel* files = lilv_world_filter_model( + world, world->model, resource, world->uris.rdfs_seeAlso, NULL, NULL); - SordIter* f = sord_begin(files); + SerdIter* f = serd_model_begin(files); int n_read = 0; - FOREACH_MATCH (f) { - const SordNode* file = sord_iter_get_node(f, SORD_OBJECT); - const uint8_t* file_str = sord_node_get_string(file); - LilvNode* file_node = lilv_node_new_from_node(world, file); - if (sord_node_get_type(file) != SORD_URI) { + for (; !serd_iter_equals(f, serd_model_end(files)); serd_iter_next(f)) { + const SerdNode* file = serd_statement_object(serd_iter_get(f)); + const char* file_str = serd_node_string(file); + LilvNode* file_node = serd_node_copy(file); + if (serd_node_type(file) != SERD_URI) { LILV_ERRORF("rdfs:seeAlso node `%s' is not a URI\n", file_str); - } else if (!lilv_world_load_graph(world, (SordNode*)file, file_node)) { + } else if (!lilv_world_load_graph(world, (SerdNode*)file, file_node)) { ++n_read; } lilv_node_free(file_node); } - sord_iter_free(f); + serd_iter_free(f); - sord_free(files); + serd_model_free(files); return n_read; } @@ -1155,31 +1104,30 @@ int lilv_world_unload_resource(LilvWorld* world, const LilvNode* resource) { if (!lilv_node_is_uri(resource) && !lilv_node_is_blank(resource)) { - LILV_ERRORF("Node `%s' is not a resource\n", - sord_node_get_string(resource->node)); + LILV_ERRORF("Node `%s' is not a resource\n", serd_node_string(resource)); return -1; } - SordModel* files = lilv_world_filter_model( - world, world->model, resource->node, world->uris.rdfs_seeAlso, NULL, NULL); + SerdModel* files = lilv_world_filter_model( + world, world->model, resource, world->uris.rdfs_seeAlso, NULL, NULL); - SordIter* f = sord_begin(files); + SerdIter* f = serd_model_begin(files); int n_dropped = 0; - FOREACH_MATCH (f) { - const SordNode* file = sord_iter_get_node(f, SORD_OBJECT); - LilvNode* file_node = lilv_node_new_from_node(world, file); - if (sord_node_get_type(file) != SORD_URI) { + for (; !serd_iter_equals(f, serd_model_end(files)); serd_iter_next(f)) { + const SerdNode* file = serd_statement_object(serd_iter_get(f)); + LilvNode* file_node = serd_node_copy(file); + if (serd_node_type(file) != SERD_URI) { LILV_ERRORF("rdfs:seeAlso node `%s' is not a URI\n", - sord_node_get_string(file)); - } else if (!lilv_world_drop_graph(world, file_node->node)) { + serd_node_string(file)); + } else if (!lilv_world_drop_graph(world, file_node)) { lilv_world_unload_file(world, file_node); ++n_dropped; } lilv_node_free(file_node); } - sord_iter_free(f); + serd_iter_free(f); - sord_free(files); + serd_model_free(files); return n_dropped; } @@ -1205,13 +1153,11 @@ LilvNode* lilv_world_get_symbol(LilvWorld* world, const LilvNode* subject) { // Check for explicitly given symbol - SordNode* snode = - sord_get(world->model, subject->node, world->uris.lv2_symbol, NULL, NULL); + const SerdNode* snode = + serd_model_get(world->model, subject, world->uris.lv2_symbol, NULL, NULL); if (snode) { - LilvNode* ret = lilv_node_new_from_node(world, snode); - sord_node_free(world->world, snode); - return ret; + return serd_node_copy(snode); } if (!lilv_node_is_uri(subject)) { @@ -1219,16 +1165,15 @@ lilv_world_get_symbol(LilvWorld* world, const LilvNode* subject) } // Find rightmost segment of URI - SerdURI uri; - serd_uri_parse((const uint8_t*)lilv_node_as_uri(subject), &uri); + SerdURIView uri = serd_parse_uri(lilv_node_as_uri(subject)); const char* str = "_"; if (uri.fragment.buf) { - str = (const char*)uri.fragment.buf + 1; + str = uri.fragment.buf + 1; } else if (uri.query.buf) { - str = (const char*)uri.query.buf; + str = uri.query.buf; } else if (uri.path.buf) { - const char* last_slash = strrchr((const char*)uri.path.buf, '/'); - str = last_slash ? (last_slash + 1) : (const char*)uri.path.buf; + const char* last_slash = strrchr(uri.path.buf, '/'); + str = last_slash ? (last_slash + 1) : uri.path.buf; } // Replace invalid characters diff --git a/test/bad_syntax.lv2/test_bad_syntax.c b/test/bad_syntax.lv2/test_bad_syntax.c index 5f10828..b1d7986 100644 --- a/test/bad_syntax.lv2/test_bad_syntax.c +++ b/test/bad_syntax.lv2/test_bad_syntax.c @@ -6,8 +6,6 @@ #include "serd/serd.h" #include <assert.h> -#include <stdbool.h> -#include <stdint.h> #include <stdio.h> #include <stdlib.h> @@ -25,13 +23,12 @@ main(int argc, char** argv) LilvWorld* world = lilv_world_new(); // Load test plugin bundle - uint8_t* abs_bundle = (uint8_t*)lilv_path_absolute(bundle_path); - SerdNode bundle = serd_node_new_file_uri(abs_bundle, 0, 0, true); - LilvNode* bundle_uri = lilv_new_uri(world, (const char*)bundle.buf); - lilv_world_load_bundle(world, bundle_uri); + char* abs_bundle = lilv_path_absolute(bundle_path); + SerdNode* bundle = + serd_new_file_uri(SERD_MEASURE_STRING(abs_bundle), SERD_EMPTY_STRING()); + lilv_world_load_bundle(world, bundle); free(abs_bundle); - serd_node_free(&bundle); - lilv_node_free(bundle_uri); + serd_node_free(bundle); LilvNode* plugin_uri = lilv_new_uri(world, PLUGIN_URI); const LilvPlugins* plugins = lilv_world_get_all_plugins(world); diff --git a/test/failed_instantiation.lv2/test_failed_instantiation.c b/test/failed_instantiation.lv2/test_failed_instantiation.c index 8dbefc3..846cdce 100644 --- a/test/failed_instantiation.lv2/test_failed_instantiation.c +++ b/test/failed_instantiation.lv2/test_failed_instantiation.c @@ -6,8 +6,6 @@ #include "serd/serd.h" #include <assert.h> -#include <stdbool.h> -#include <stdint.h> #include <stdio.h> #include <stdlib.h> @@ -25,13 +23,12 @@ main(int argc, char** argv) LilvWorld* world = lilv_world_new(); // Load test plugin bundle - uint8_t* abs_bundle = (uint8_t*)lilv_path_absolute(bundle_path); - SerdNode bundle = serd_node_new_file_uri(abs_bundle, 0, 0, true); - LilvNode* bundle_uri = lilv_new_uri(world, (const char*)bundle.buf); - lilv_world_load_bundle(world, bundle_uri); + char* abs_bundle = lilv_path_absolute(bundle_path); + SerdNode* bundle = + serd_new_file_uri(SERD_MEASURE_STRING(abs_bundle), SERD_EMPTY_STRING()); + lilv_world_load_bundle(world, bundle); free(abs_bundle); - serd_node_free(&bundle); - lilv_node_free(bundle_uri); + serd_node_free(bundle); LilvNode* plugin_uri = lilv_new_uri(world, PLUGIN_URI); const LilvPlugins* plugins = lilv_world_get_all_plugins(world); diff --git a/test/failed_lib_descriptor.lv2/test_failed_lib_descriptor.c b/test/failed_lib_descriptor.lv2/test_failed_lib_descriptor.c index 71a3b96..9d2c377 100644 --- a/test/failed_lib_descriptor.lv2/test_failed_lib_descriptor.c +++ b/test/failed_lib_descriptor.lv2/test_failed_lib_descriptor.c @@ -6,8 +6,6 @@ #include "serd/serd.h" #include <assert.h> -#include <stdbool.h> -#include <stdint.h> #include <stdio.h> #include <stdlib.h> @@ -25,13 +23,12 @@ main(int argc, char** argv) LilvWorld* world = lilv_world_new(); // Load test plugin bundle - uint8_t* abs_bundle = (uint8_t*)lilv_path_absolute(bundle_path); - SerdNode bundle = serd_node_new_file_uri(abs_bundle, 0, 0, true); - LilvNode* bundle_uri = lilv_new_uri(world, (const char*)bundle.buf); - lilv_world_load_bundle(world, bundle_uri); + char* abs_bundle = lilv_path_absolute(bundle_path); + SerdNode* bundle = + serd_new_file_uri(SERD_MEASURE_STRING(abs_bundle), SERD_EMPTY_STRING()); + lilv_world_load_bundle(world, bundle); free(abs_bundle); - serd_node_free(&bundle); - lilv_node_free(bundle_uri); + serd_node_free(bundle); LilvNode* plugin_uri = lilv_new_uri(world, PLUGIN_URI); const LilvPlugins* plugins = lilv_world_get_all_plugins(world); diff --git a/test/lib_descriptor.lv2/test_lib_descriptor.c b/test/lib_descriptor.lv2/test_lib_descriptor.c index bf79be8..650dd79 100644 --- a/test/lib_descriptor.lv2/test_lib_descriptor.c +++ b/test/lib_descriptor.lv2/test_lib_descriptor.c @@ -6,8 +6,6 @@ #include "serd/serd.h" #include <assert.h> -#include <stdbool.h> -#include <stdint.h> #include <stdio.h> #include <stdlib.h> @@ -25,13 +23,12 @@ main(int argc, char** argv) LilvWorld* world = lilv_world_new(); // Load test plugin bundle - uint8_t* abs_bundle = (uint8_t*)lilv_path_absolute(bundle_path); - SerdNode bundle = serd_node_new_file_uri(abs_bundle, 0, 0, true); - LilvNode* bundle_uri = lilv_new_uri(world, (const char*)bundle.buf); - lilv_world_load_bundle(world, bundle_uri); + char* abs_bundle = lilv_path_absolute(bundle_path); + SerdNode* bundle = + serd_new_file_uri(SERD_MEASURE_STRING(abs_bundle), SERD_EMPTY_STRING()); + lilv_world_load_bundle(world, bundle); free(abs_bundle); - serd_node_free(&bundle); - lilv_node_free(bundle_uri); + serd_node_free(bundle); LilvNode* plugin_uri = lilv_new_uri(world, PLUGIN_URI); const LilvPlugins* plugins = lilv_world_get_all_plugins(world); diff --git a/test/lilv_test_uri_map.h b/test/lilv_test_uri_map.h index 5f85c86..e976381 100644 --- a/test/lilv_test_uri_map.h +++ b/test/lilv_test_uri_map.h @@ -63,7 +63,7 @@ map_uri(LV2_URID_Map_Handle handle, const char* uri) } } - assert(serd_uri_string_has_scheme((const uint8_t*)uri)); + assert(serd_uri_string_has_scheme(uri)); map->uris = (char**)realloc(map->uris, ++map->n_uris * sizeof(char*)); map->uris[map->n_uris - 1] = lilv_strdup(uri); diff --git a/test/lilv_test_utils.c b/test/lilv_test_utils.c index bc6eb3d..7a494ce 100644 --- a/test/lilv_test_utils.c +++ b/test/lilv_test_utils.c @@ -94,15 +94,15 @@ create_bundle(LilvTestEnv* env, return 1; } - SerdNode s = serd_node_new_file_uri( - (const uint8_t*)env->test_bundle_path, NULL, NULL, true); + SerdNode* s = serd_new_file_uri(SERD_MEASURE_STRING(env->test_bundle_path), + SERD_EMPTY_STRING()); - env->test_bundle_uri = lilv_new_uri(env->world, (const char*)s.buf); + env->test_bundle_uri = lilv_new_uri(env->world, serd_node_string(s)); env->test_manifest_path = lilv_path_join(env->test_bundle_path, "manifest.ttl"); env->test_content_path = lilv_path_join(env->test_bundle_path, "plugin.ttl"); - serd_node_free(&s); + serd_node_free(s); FILE* const manifest_file = fopen(env->test_manifest_path, "w"); if (!manifest_file) { diff --git a/test/missing_descriptor.lv2/test_missing_descriptor.c b/test/missing_descriptor.lv2/test_missing_descriptor.c index 330e534..00ed8ae 100644 --- a/test/missing_descriptor.lv2/test_missing_descriptor.c +++ b/test/missing_descriptor.lv2/test_missing_descriptor.c @@ -6,8 +6,6 @@ #include "serd/serd.h" #include <assert.h> -#include <stdbool.h> -#include <stdint.h> #include <stdio.h> #include <stdlib.h> @@ -25,13 +23,12 @@ main(int argc, char** argv) LilvWorld* world = lilv_world_new(); // Load test plugin bundle - uint8_t* abs_bundle = (uint8_t*)lilv_path_absolute(bundle_path); - SerdNode bundle = serd_node_new_file_uri(abs_bundle, 0, 0, true); - LilvNode* bundle_uri = lilv_new_uri(world, (const char*)bundle.buf); - lilv_world_load_bundle(world, bundle_uri); + char* abs_bundle = lilv_path_absolute(bundle_path); + SerdNode* bundle = + serd_new_file_uri(SERD_MEASURE_STRING(abs_bundle), SERD_EMPTY_STRING()); + lilv_world_load_bundle(world, bundle); free(abs_bundle); - serd_node_free(&bundle); - lilv_node_free(bundle_uri); + serd_node_free(bundle); LilvNode* plugin_uri = lilv_new_uri(world, PLUGIN_URI); const LilvPlugins* plugins = lilv_world_get_all_plugins(world); diff --git a/test/missing_name.lv2/test_missing_name.c b/test/missing_name.lv2/test_missing_name.c index 5cb069a..78f1cab 100644 --- a/test/missing_name.lv2/test_missing_name.c +++ b/test/missing_name.lv2/test_missing_name.c @@ -6,8 +6,6 @@ #include "serd/serd.h" #include <assert.h> -#include <stdbool.h> -#include <stdint.h> #include <stdio.h> #include <stdlib.h> @@ -25,13 +23,12 @@ main(int argc, char** argv) LilvWorld* world = lilv_world_new(); // Load test plugin bundle - uint8_t* abs_bundle = (uint8_t*)lilv_path_absolute(bundle_path); - SerdNode bundle = serd_node_new_file_uri(abs_bundle, 0, 0, true); - LilvNode* bundle_uri = lilv_new_uri(world, (const char*)bundle.buf); - lilv_world_load_bundle(world, bundle_uri); + char* abs_bundle = lilv_path_absolute(bundle_path); + SerdNode* bundle = + serd_new_file_uri(SERD_MEASURE_STRING(abs_bundle), SERD_EMPTY_STRING()); + lilv_world_load_bundle(world, bundle); free(abs_bundle); - serd_node_free(&bundle); - lilv_node_free(bundle_uri); + serd_node_free(bundle); LilvNode* plugin_uri = lilv_new_uri(world, PLUGIN_URI); const LilvPlugins* plugins = lilv_world_get_all_plugins(world); diff --git a/test/missing_plugin.lv2/test_missing_plugin.c b/test/missing_plugin.lv2/test_missing_plugin.c index 861fcba..84e664d 100644 --- a/test/missing_plugin.lv2/test_missing_plugin.c +++ b/test/missing_plugin.lv2/test_missing_plugin.c @@ -6,8 +6,6 @@ #include "serd/serd.h" #include <assert.h> -#include <stdbool.h> -#include <stdint.h> #include <stdio.h> #include <stdlib.h> @@ -25,13 +23,12 @@ main(int argc, char** argv) LilvWorld* world = lilv_world_new(); // Load test plugin bundle - uint8_t* abs_bundle = (uint8_t*)lilv_path_absolute(bundle_path); - SerdNode bundle = serd_node_new_file_uri(abs_bundle, 0, 0, true); - LilvNode* bundle_uri = lilv_new_uri(world, (const char*)bundle.buf); - lilv_world_load_bundle(world, bundle_uri); + char* abs_bundle = lilv_path_absolute(bundle_path); + SerdNode* bundle = + serd_new_file_uri(SERD_MEASURE_STRING(abs_bundle), SERD_EMPTY_STRING()); + lilv_world_load_bundle(world, bundle); free(abs_bundle); - serd_node_free(&bundle); - lilv_node_free(bundle_uri); + serd_node_free(bundle); LilvNode* plugin_uri = lilv_new_uri(world, PLUGIN_URI); const LilvPlugins* plugins = lilv_world_get_all_plugins(world); diff --git a/test/missing_port.lv2/test_missing_port.c b/test/missing_port.lv2/test_missing_port.c index ec6713c..c752399 100644 --- a/test/missing_port.lv2/test_missing_port.c +++ b/test/missing_port.lv2/test_missing_port.c @@ -6,8 +6,6 @@ #include "serd/serd.h" #include <assert.h> -#include <stdbool.h> -#include <stdint.h> #include <stdio.h> #include <stdlib.h> @@ -25,13 +23,12 @@ main(int argc, char** argv) LilvWorld* world = lilv_world_new(); // Load test plugin bundle - uint8_t* abs_bundle = (uint8_t*)lilv_path_absolute(bundle_path); - SerdNode bundle = serd_node_new_file_uri(abs_bundle, 0, 0, true); - LilvNode* bundle_uri = lilv_new_uri(world, (const char*)bundle.buf); - lilv_world_load_bundle(world, bundle_uri); + char* const abs_bundle = lilv_path_absolute(bundle_path); + const SerdStringView abs_bundle_view = SERD_MEASURE_STRING(abs_bundle); + SerdNode* bundle = serd_new_file_uri(abs_bundle_view, SERD_EMPTY_STRING()); + lilv_world_load_bundle(world, bundle); free(abs_bundle); - serd_node_free(&bundle); - lilv_node_free(bundle_uri); + serd_node_free(bundle); LilvNode* plugin_uri = lilv_new_uri(world, PLUGIN_URI); const LilvPlugins* plugins = lilv_world_get_all_plugins(world); diff --git a/test/missing_port_name.lv2/test_missing_port_name.c b/test/missing_port_name.lv2/test_missing_port_name.c index 4d017d9..d61fa63 100644 --- a/test/missing_port_name.lv2/test_missing_port_name.c +++ b/test/missing_port_name.lv2/test_missing_port_name.c @@ -6,8 +6,6 @@ #include "serd/serd.h" #include <assert.h> -#include <stdbool.h> -#include <stdint.h> #include <stdio.h> #include <stdlib.h> @@ -25,13 +23,12 @@ main(int argc, char** argv) LilvWorld* world = lilv_world_new(); // Load test plugin bundle - uint8_t* abs_bundle = (uint8_t*)lilv_path_absolute(bundle_path); - SerdNode bundle = serd_node_new_file_uri(abs_bundle, 0, 0, true); - LilvNode* bundle_uri = lilv_new_uri(world, (const char*)bundle.buf); - lilv_world_load_bundle(world, bundle_uri); + char* abs_bundle = lilv_path_absolute(bundle_path); + SerdNode* bundle = + serd_new_file_uri(SERD_MEASURE_STRING(abs_bundle), SERD_EMPTY_STRING()); + lilv_world_load_bundle(world, bundle); free(abs_bundle); - serd_node_free(&bundle); - lilv_node_free(bundle_uri); + serd_node_free(bundle); LilvNode* plugin_uri = lilv_new_uri(world, PLUGIN_URI); const LilvPlugins* plugins = lilv_world_get_all_plugins(world); diff --git a/test/test_state.c b/test/test_state.c index 533c3a9..e12bfdc 100644 --- a/test/test_state.c +++ b/test/test_state.c @@ -246,10 +246,12 @@ static const LilvPlugin* load_test_plugin(const TestContext* const ctx) { LilvWorld* world = ctx->env->world; - uint8_t* abs_bundle = (uint8_t*)lilv_path_absolute(LILV_TEST_BUNDLE); - SerdNode bundle = serd_node_new_file_uri(abs_bundle, 0, 0, true); - LilvNode* bundle_uri = lilv_new_uri(world, (const char*)bundle.buf); - LilvNode* plugin_uri = lilv_new_uri(world, TEST_PLUGIN_URI); + char* abs_bundle = lilv_path_absolute(LILV_TEST_BUNDLE); + SerdNode* bundle = + serd_new_file_uri(SERD_MEASURE_STRING(abs_bundle), SERD_EMPTY_STRING()); + + LilvNode* bundle_uri = lilv_new_uri(world, serd_node_string(bundle)); + LilvNode* plugin_uri = lilv_new_uri(world, TEST_PLUGIN_URI); lilv_world_load_bundle(world, bundle_uri); @@ -258,7 +260,7 @@ load_test_plugin(const TestContext* const ctx) lilv_node_free(plugin_uri); lilv_node_free(bundle_uri); - serd_node_free(&bundle); + serd_node_free(bundle); free(abs_bundle); assert(plugin); @@ -531,26 +533,13 @@ test_string_round_trip(void) } static SerdStatus -count_sink(void* const handle, - const SerdStatementFlags flags, - const SerdNode* const graph, - const SerdNode* const subject, - const SerdNode* const predicate, - const SerdNode* const object, - const SerdNode* const object_datatype, - const SerdNode* const object_lang) +count_func(void* const handle, const SerdEvent* const event) { - (void)flags; - (void)graph; - (void)subject; - (void)predicate; - (void)object; - (void)object_datatype; - (void)object_lang; - size_t* const n_statements = (size_t*)handle; - ++(*n_statements); + if (event->type == SERD_STATEMENT) { + ++(*n_statements); + } return SERD_SUCCESS; } @@ -560,15 +549,27 @@ count_statements(const char* path) { size_t n_statements = 0; - SerdReader* reader = serd_reader_new( - SERD_TURTLE, &n_statements, NULL, NULL, NULL, count_sink, NULL); + SerdWorld* const world = serd_world_new(); + const SerdStringView path_view = SERD_MEASURE_STRING(path); + SerdNode* const base = serd_new_file_uri(path_view, SERD_EMPTY_STRING()); + + SerdEnv* const env = serd_env_new(serd_node_string_view(base)); + SerdSink* const sink = serd_sink_new(&n_statements, count_func, NULL); + SerdReader* const reader = + serd_reader_new(world, SERD_TURTLE, 0, env, sink, 4096); - SerdNode uri = serd_node_new_file_uri((const uint8_t*)path, NULL, NULL, true); + SerdByteSource* const source = serd_byte_source_new_filename(path, 4096); - assert(!serd_reader_read_file(reader, uri.buf)); + SerdStatus st = SERD_SUCCESS; + assert(!(st = serd_reader_start(reader, source))); + assert(!(st = serd_reader_read_document(reader))); - serd_node_free(&uri); + serd_byte_source_free(source); serd_reader_free(reader); + serd_sink_free(sink); + serd_env_free(env); + serd_node_free(base); + serd_world_free(world); return n_statements; } @@ -917,10 +918,10 @@ test_world_round_trip(void) "state.ttl")); // Load state bundle into world - SerdNode bundle_uri = - serd_node_new_file_uri((const uint8_t*)bundle_path, 0, 0, true); + SerdNode* bundle_uri = + serd_new_file_uri(SERD_MEASURE_STRING(bundle_path), SERD_EMPTY_STRING()); LilvNode* const bundle_node = - lilv_new_uri(world, (const char*)bundle_uri.buf); + lilv_new_uri(world, serd_node_string(bundle_uri)); LilvNode* const state_node = lilv_new_uri(world, state_uri); lilv_world_load_bundle(world, bundle_node); lilv_world_load_resource(world, state_node); @@ -944,7 +945,7 @@ test_world_round_trip(void) lilv_state_free(restored); lilv_node_free(state_node); lilv_node_free(bundle_node); - serd_node_free(&bundle_uri); + serd_node_free(bundle_uri); lilv_state_free(start_state); free(bundle_path); test_context_free(ctx); |