From 22f4ed918d99c17cd3bb8890eeaac173060394bf Mon Sep 17 00:00:00 2001 From: David Robillard Date: Fri, 29 Apr 2011 16:09:20 +0000 Subject: Remove LilvNode and LilvMatches typedefs for Sord stuff. git-svn-id: http://svn.drobilla.net/lad/trunk/lilv@3233 a436a847-0d15-0410-975c-d299462d15a1 --- src/lilv_internal.h | 53 ++++++++++++++---------------- src/plugin.c | 54 +++++++++++++++--------------- src/pluginclass.c | 8 ++--- src/port.c | 28 ++++++++-------- src/query.c | 20 ++++++------ src/value.c | 2 +- src/world.c | 94 ++++++++++++++++++++++++++--------------------------- 7 files changed, 128 insertions(+), 131 deletions(-) (limited to 'src') diff --git a/src/lilv_internal.h b/src/lilv_internal.h index 6b118ee..774f5fd 100644 --- a/src/lilv_internal.h +++ b/src/lilv_internal.h @@ -55,28 +55,25 @@ static inline char* dlerror(void) { return "Unknown error"; } #define LILV_NS_XSD "http://www.w3.org/2001/XMLSchema#" #define LILV_NS_RDF "http://www.w3.org/1999/02/22-rdf-syntax-ns#" -typedef SordIter* LilvMatches; -typedef const SordNode* LilvNode; - #define FOREACH_MATCH(iter) \ for (; !sord_iter_end(iter); sord_iter_next(iter)) static inline const SordNode* -lilv_match_subject(LilvMatches iter) { +lilv_match_subject(SordIter* iter) { SordQuad tup; sord_iter_get(iter, tup); return tup[SORD_SUBJECT]; } static inline const SordNode* -lilv_match_object(LilvMatches iter) { +lilv_match_object(SordIter* iter) { SordQuad tup; sord_iter_get(iter, tup); return tup[SORD_OBJECT]; } static inline void -lilv_match_end(LilvMatches iter) +lilv_match_end(SordIter* iter) { sord_iter_free(iter); } @@ -139,8 +136,8 @@ void lilv_plugin_free(LilvPlugin* plugin); LilvValue* lilv_plugin_get_unique(const LilvPlugin* p, - LilvNode subject, - LilvNode predicate); + const SordNode* subject, + const SordNode* predicate); /* ********* Plugins ********* */ @@ -194,10 +191,10 @@ struct LilvPluginClassImpl { LilvValue* label; }; -LilvPluginClass* lilv_plugin_class_new(LilvWorld* world, - LilvNode parent_uri, - LilvNode uri, - const char* label); +LilvPluginClass* lilv_plugin_class_new(LilvWorld* world, + const SordNode* parent_uri, + const SordNode* uri, + const char* label); void lilv_plugin_class_free(LilvPluginClass* plugin_class); @@ -304,8 +301,8 @@ struct LilvValueImpl { }; LilvValue* lilv_value_new(LilvWorld* world, LilvValueType type, const char* val); -LilvValue* lilv_value_new_from_node(LilvWorld* world, LilvNode node); -LilvNode lilv_value_as_node(const LilvValue* value); +LilvValue* lilv_value_new_from_node(LilvWorld* world, const SordNode* node); +const SordNode* lilv_value_as_node(const LilvValue* value); int lilv_header_compare_by_uri(const void* a, const void* b, void* user_data); @@ -324,7 +321,7 @@ lilv_array_append(GSequence* seq, void* value) { struct LilvHeader* lilv_sequence_get_by_uri(const GSequence* seq, const LilvValue* uri); -static inline SordNode* lilv_node_copy(LilvNode node) { +static inline SordNode* lilv_node_copy(const SordNode* node) { return sord_node_copy(node); } @@ -344,28 +341,28 @@ void lilv_scale_point_free(LilvScalePoint* point); /* ********* Query Results ********* */ -LilvMatches -lilv_world_query(LilvWorld* world, - LilvNode subject, - LilvNode predicate, - LilvNode object); +SordIter* +lilv_world_query(LilvWorld* world, + const SordNode* subject, + const SordNode* predicate, + const SordNode* object); LilvValues* -lilv_world_query_values(LilvWorld* world, - LilvNode subject, - LilvNode predicate, - LilvNode object); +lilv_world_query_values(LilvWorld* world, + const SordNode* subject, + const SordNode* predicate, + const SordNode* object); -static inline bool lilv_matches_next(LilvMatches matches) { +static inline bool lilv_matches_next(SordIter* matches) { return sord_iter_next(matches); } -static inline bool lilv_matches_end(LilvMatches matches) { +static inline bool lilv_matches_end(SordIter* matches) { return sord_iter_end(matches); } -LilvValues* lilv_values_from_stream_objects(LilvWorld* w, - LilvMatches stream); +LilvValues* lilv_values_from_stream_objects(LilvWorld* w, + SordIter* stream); /* ********* Utilities ********* */ diff --git a/src/plugin.c b/src/plugin.c index 224cd97..3703ed6 100644 --- a/src/plugin.c +++ b/src/plugin.c @@ -82,7 +82,7 @@ lilv_plugin_free(LilvPlugin* p) } LilvValue* -lilv_plugin_get_unique(const LilvPlugin* p, LilvNode subject, LilvNode predicate) +lilv_plugin_get_unique(const LilvPlugin* p, const SordNode* subject, const SordNode* predicate) { LilvValues* values = lilv_world_query_values(p->world, subject, predicate, NULL); @@ -97,7 +97,7 @@ lilv_plugin_get_unique(const LilvPlugin* p, LilvNode subject, LilvNode predicate } static LilvValue* -lilv_plugin_get_one(const LilvPlugin* p, LilvNode subject, LilvNode predicate) +lilv_plugin_get_one(const LilvPlugin* p, const SordNode* subject, const SordNode* predicate) { LilvValues* values = lilv_world_query_values(p->world, subject, predicate, NULL); @@ -177,7 +177,7 @@ lilv_plugin_load_ports_if_necessary(const LilvPlugin* const_p) p->ports = malloc(sizeof(LilvPort*)); p->ports[0] = NULL; - LilvMatches ports = lilv_world_query( + SordIter* ports = lilv_world_query( p->world, p->plugin_uri->val.uri_val, p->world->lv2_port_node, @@ -185,7 +185,7 @@ lilv_plugin_load_ports_if_necessary(const LilvPlugin* const_p) FOREACH_MATCH(ports) { LilvValue* index = NULL; - LilvNode port = lilv_match_object(ports); + const SordNode* port = lilv_match_object(ports); LilvValue* symbol = lilv_plugin_get_unique( p, port, p->world->lv2_symbol_node); @@ -222,10 +222,10 @@ lilv_plugin_load_ports_if_necessary(const LilvPlugin* const_p) p->ports[this_index] = this_port; } - LilvMatches types = lilv_world_query( + SordIter* types = lilv_world_query( p->world, port, p->world->rdf_a_node, NULL); FOREACH_MATCH(types) { - LilvNode type = lilv_match_object(types); + const SordNode* type = lilv_match_object(types); if (sord_node_get_type(type) == SORD_URI) { lilv_array_append( this_port->classes, @@ -286,13 +286,13 @@ lilv_plugin_get_library_uri(const LilvPlugin* const_p) lilv_plugin_load_if_necessary(p); if (!p->binary_uri) { // lv2:binary ?binary - LilvMatches results = lilv_world_query( + SordIter* results = lilv_world_query( p->world, p->plugin_uri->val.uri_val, p->world->lv2_binary_node, NULL); FOREACH_MATCH(results) { - LilvNode binary_node = lilv_match_object(results); + const SordNode* binary_node = lilv_match_object(results); if (sord_node_get_type(binary_node) == SORD_URI) { p->binary_uri = lilv_value_new_from_node(p->world, binary_node); break; @@ -322,13 +322,13 @@ lilv_plugin_get_class(const LilvPlugin* const_p) lilv_plugin_load_if_necessary(p); if (!p->plugin_class) { // a ?class - LilvMatches results = lilv_world_query( + SordIter* results = lilv_world_query( p->world, p->plugin_uri->val.uri_val, p->world->rdf_a_node, NULL); FOREACH_MATCH(results) { - LilvNode class_node = lilv_match_object(results); + const SordNode* class_node = lilv_match_object(results); if (sord_node_get_type(class_node) != SORD_URI) { continue; } @@ -520,7 +520,7 @@ bool lilv_plugin_has_latency(const LilvPlugin* p) { lilv_plugin_load_if_necessary(p); - LilvMatches ports = lilv_world_query( + SordIter* ports = lilv_world_query( p->world, p->plugin_uri->val.uri_val, p->world->lv2_port_node, @@ -528,8 +528,8 @@ lilv_plugin_has_latency(const LilvPlugin* p) bool ret = false; FOREACH_MATCH(ports) { - LilvNode port = lilv_match_object(ports); - LilvMatches reports_latency = lilv_world_query( + const SordNode* port = lilv_match_object(ports); + SordIter* reports_latency = lilv_world_query( p->world, port, p->world->lv2_portproperty_node, @@ -551,7 +551,7 @@ uint32_t lilv_plugin_get_latency_port_index(const LilvPlugin* p) { lilv_plugin_load_if_necessary(p); - LilvMatches ports = lilv_world_query( + SordIter* ports = lilv_world_query( p->world, p->plugin_uri->val.uri_val, p->world->lv2_port_node, @@ -559,8 +559,8 @@ lilv_plugin_get_latency_port_index(const LilvPlugin* p) uint32_t ret = 0; FOREACH_MATCH(ports) { - LilvNode port = lilv_match_object(ports); - LilvMatches reports_latency = lilv_world_query( + const SordNode* port = lilv_match_object(ports); + SordIter* reports_latency = lilv_world_query( p->world, port, p->world->lv2_portproperty_node, @@ -656,7 +656,7 @@ lilv_plugin_get_port_by_symbol(const LilvPlugin* p, return NULL; } -static LilvNode +static const SordNode* lilv_plugin_get_author(const LilvPlugin* p) { lilv_plugin_load_if_necessary(p); @@ -664,7 +664,7 @@ lilv_plugin_get_author(const LilvPlugin* p) SordNode* doap_maintainer = sord_new_uri( p->world->world, NS_DOAP "maintainer"); - LilvMatches maintainers = lilv_world_query( + SordIter* maintainers = lilv_world_query( p->world, p->plugin_uri->val.uri_val, doap_maintainer, @@ -676,7 +676,7 @@ lilv_plugin_get_author(const LilvPlugin* p) return NULL; } - LilvNode author = lilv_match_object(maintainers); + const SordNode* author = lilv_match_object(maintainers); lilv_match_end(maintainers); return author; @@ -686,7 +686,7 @@ LILV_API LilvValue* lilv_plugin_get_author_name(const LilvPlugin* plugin) { - LilvNode author = lilv_plugin_get_author(plugin); + const SordNode* author = lilv_plugin_get_author(plugin); if (author) { return lilv_plugin_get_one( plugin, author, sord_new_uri( @@ -699,7 +699,7 @@ LILV_API LilvValue* lilv_plugin_get_author_email(const LilvPlugin* plugin) { - LilvNode author = lilv_plugin_get_author(plugin); + const SordNode* author = lilv_plugin_get_author(plugin); if (author) { return lilv_plugin_get_one( plugin, author, sord_new_uri( @@ -712,7 +712,7 @@ LILV_API LilvValue* lilv_plugin_get_author_homepage(const LilvPlugin* plugin) { - LilvNode author = lilv_plugin_get_author(plugin); + const SordNode* author = lilv_plugin_get_author(plugin); if (author) { return lilv_plugin_get_one( plugin, author, sord_new_uri( @@ -737,17 +737,17 @@ lilv_plugin_get_uis(const LilvPlugin* p) SordNode* ui_ui_node = sord_new_uri(p->world->world, NS_UI "ui"); SordNode* ui_binary_node = sord_new_uri(p->world->world, NS_UI "binary"); - LilvUIs* result = lilv_uis_new(); - LilvMatches uis = lilv_world_query( + LilvUIs* result = lilv_uis_new(); + SordIter* uis = lilv_world_query( p->world, p->plugin_uri->val.uri_val, ui_ui_node, NULL); FOREACH_MATCH(uis) { - LilvNode ui = lilv_match_object(uis); - LilvValue* type = lilv_plugin_get_unique(p, ui, p->world->rdf_a_node); - LilvValue* binary = lilv_plugin_get_unique(p, ui, ui_binary_node); + const SordNode* ui = lilv_match_object(uis); + LilvValue* type = lilv_plugin_get_unique(p, ui, p->world->rdf_a_node); + LilvValue* binary = lilv_plugin_get_unique(p, ui, ui_binary_node); if (sord_node_get_type(ui) != SORD_URI || !lilv_value_is_uri(type) diff --git a/src/pluginclass.c b/src/pluginclass.c index 010f99e..60e57dc 100644 --- a/src/pluginclass.c +++ b/src/pluginclass.c @@ -23,10 +23,10 @@ #include "lilv_internal.h" LilvPluginClass* -lilv_plugin_class_new(LilvWorld* world, - LilvNode parent_node, - LilvNode uri, - const char* label) +lilv_plugin_class_new(LilvWorld* world, + const SordNode* parent_node, + const SordNode* uri, + const char* label) { if (parent_node && sord_node_get_type(parent_node) != SORD_URI) { return NULL; // Not an LV2 plugin superclass (FIXME: discover properly) diff --git a/src/port.c b/src/port.c index 3845d29..6f3f560 100644 --- a/src/port.c +++ b/src/port.c @@ -55,18 +55,18 @@ lilv_port_is_a(const LilvPlugin* plugin, return false; } -static LilvNode +static const SordNode* lilv_port_get_node(const LilvPlugin* p, const LilvPort* port) { - LilvMatches ports = lilv_world_query( + SordIter* ports = lilv_world_query( p->world, p->plugin_uri->val.uri_val, p->world->lv2_port_node, NULL); - LilvNode ret = NULL; + const SordNode* ret = NULL; FOREACH_MATCH(ports) { - LilvNode node = lilv_match_object(ports); + const SordNode* node = lilv_match_object(ports); LilvValue* symbol = lilv_plugin_get_unique( p, node, @@ -93,8 +93,8 @@ lilv_port_has_property(const LilvPlugin* p, const LilvValue* property) { assert(property); - LilvNode port_node = lilv_port_get_node(p, port); - LilvMatches results = lilv_world_query( + const SordNode* port_node = lilv_port_get_node(p, port); + SordIter* results = lilv_world_query( p->world, port_node, p->world->lv2_portproperty_node, @@ -114,8 +114,8 @@ lilv_port_supports_event(const LilvPlugin* p, #define NS_EV (const uint8_t*)"http://lv2plug.in/ns/ext/event#" assert(event); - LilvNode port_node = lilv_port_get_node(p, port); - LilvMatches results = lilv_world_query( + const SordNode* port_node = lilv_port_get_node(p, port); + SordIter* results = lilv_world_query( p->world, port_node, sord_new_uri(p->world->world, NS_EV "supportsEvent"), @@ -129,12 +129,12 @@ lilv_port_supports_event(const LilvPlugin* p, static LilvValues* lilv_port_get_value_by_node(const LilvPlugin* p, const LilvPort* port, - LilvNode predicate) + const SordNode* predicate) { assert(sord_node_get_type(predicate) == SORD_URI); - LilvNode port_node = lilv_port_get_node(p, port); - LilvMatches results = lilv_world_query( + const SordNode* port_node = lilv_port_get_node(p, port); + SordIter* results = lilv_world_query( p->world, port_node, predicate, @@ -237,8 +237,8 @@ LilvScalePoints* lilv_port_get_scale_points(const LilvPlugin* p, const LilvPort* port) { - LilvNode port_node = lilv_port_get_node(p, port); - LilvMatches points = lilv_world_query( + const SordNode* port_node = lilv_port_get_node(p, port); + SordIter* points = lilv_world_query( p->world, port_node, sord_new_uri(p->world->world, (const uint8_t*)LILV_NS_LV2 "scalePoint"), @@ -249,7 +249,7 @@ lilv_port_get_scale_points(const LilvPlugin* p, ret = lilv_scale_points_new(); FOREACH_MATCH(points) { - LilvNode point = lilv_match_object(points); + const SordNode* point = lilv_match_object(points); LilvValue* value = lilv_plugin_get_unique( p, diff --git a/src/query.c b/src/query.c index bea8788..c55fe5b 100644 --- a/src/query.c +++ b/src/query.c @@ -54,15 +54,15 @@ lilv_lang_matches(const char* a, const char* b) } LilvValues* -lilv_values_from_stream_objects_i18n(LilvWorld* world, - LilvMatches stream) +lilv_values_from_stream_objects_i18n(LilvWorld* world, + SordIter* stream) { - LilvValues* values = lilv_values_new(); - LilvNode nolang = NULL; // Untranslated value - LilvNode partial = NULL; // Partial language match - char* syslang = lilv_get_lang(); + LilvValues* values = lilv_values_new(); + const SordNode* nolang = NULL; // Untranslated value + const SordNode* partial = NULL; // Partial language match + char* syslang = lilv_get_lang(); FOREACH_MATCH(stream) { - LilvNode value = lilv_match_object(stream); + const SordNode* value = lilv_match_object(stream); if (sord_node_get_type(value) == SORD_LITERAL) { const char* lang = sord_node_get_language(value); LilvLangMatch lm = LILV_LANG_MATCH_NONE; @@ -95,7 +95,7 @@ lilv_values_from_stream_objects_i18n(LilvWorld* world, return values; } - LilvNode best = nolang; + const SordNode* best = nolang; if (syslang && partial) { // Partial language match for system language best = partial; @@ -117,8 +117,8 @@ lilv_values_from_stream_objects_i18n(LilvWorld* world, } LilvValues* -lilv_values_from_stream_objects(LilvWorld* world, - LilvMatches stream) +lilv_values_from_stream_objects(LilvWorld* world, + SordIter* stream) { if (lilv_matches_end(stream)) { lilv_match_end(stream); diff --git a/src/value.c b/src/value.c index 94d37f8..f50c6bd 100644 --- a/src/value.c +++ b/src/value.c @@ -312,7 +312,7 @@ lilv_value_as_uri(const LilvValue* value) return value->str_val; } -LilvNode +const SordNode* lilv_value_as_node(const LilvValue* value) { assert(lilv_value_is_uri(value)); diff --git a/src/world.c b/src/world.c index 4fba762..8bc4b49 100644 --- a/src/world.c +++ b/src/world.c @@ -200,33 +200,33 @@ lilv_world_set_option(LilvWorld* world, LILV_WARNF("Unrecognized or invalid option `%s'\n", option); } -static LilvMatches -lilv_world_find_statements(LilvWorld* world, - SordModel* model, - LilvNode subject, - LilvNode predicate, - LilvNode object, - LilvNode graph) +static SordIter* +lilv_world_find_statements(LilvWorld* world, + SordModel* model, + const SordNode* subject, + const SordNode* predicate, + const SordNode* object, + const SordNode* graph) { SordQuad pat = { subject, predicate, object, graph }; return sord_find(model, pat); } -LilvMatches -lilv_world_query(LilvWorld* world, - LilvNode subject, - LilvNode predicate, - LilvNode object) +SordIter* +lilv_world_query(LilvWorld* world, + const SordNode* subject, + const SordNode* predicate, + const SordNode* object) { return lilv_world_find_statements(world, world->model, subject, predicate, object, NULL); } LilvValues* -lilv_world_query_values(LilvWorld* world, - LilvNode subject, - LilvNode predicate, - LilvNode object) +lilv_world_query_values(LilvWorld* world, + const SordNode* subject, + const SordNode* predicate, + const SordNode* object) { return lilv_values_from_stream_objects(world, lilv_world_query(world, subject, predicate, object)); @@ -295,9 +295,9 @@ lilv_sequence_get_by_uri(const GSequence* const_seq, } static void -lilv_world_add_spec(LilvWorld* world, - LilvNode specification_node, - LilvNode bundle_node) +lilv_world_add_spec(LilvWorld* world, + const SordNode* specification_node, + const SordNode* bundle_node) { LilvSpec* spec = malloc(sizeof(struct LilvSpecImpl)); spec->spec = lilv_node_copy(specification_node); @@ -305,14 +305,14 @@ lilv_world_add_spec(LilvWorld* world, spec->data_uris = lilv_values_new(); // Add all plugin data files (rdfs:seeAlso) - LilvMatches files = lilv_world_find_statements( + SordIter* files = lilv_world_find_statements( world, world->model, specification_node, world->rdfs_seealso_node, NULL, NULL); FOREACH_MATCH(files) { - LilvNode file_node = lilv_match_object(files); + const SordNode* file_node = lilv_match_object(files); lilv_array_append(spec->data_uris, lilv_value_new_from_node(world, file_node)); } @@ -323,11 +323,11 @@ lilv_world_add_spec(LilvWorld* world, } static void -lilv_world_add_plugin(LilvWorld* world, - LilvNode plugin_node, - SerdNode* manifest_uri, - LilvNode dyn_manifest_lib, - LilvNode bundle_node) +lilv_world_add_plugin(LilvWorld* world, + const SordNode* plugin_node, + SerdNode* manifest_uri, + const SordNode* dyn_manifest_lib, + const SordNode* bundle_node) { LilvValue* plugin_uri = lilv_value_new_from_node(world, plugin_node); @@ -355,14 +355,14 @@ lilv_world_add_plugin(LilvWorld* world, } // Add all plugin data files (rdfs:seeAlso) - LilvMatches files = lilv_world_find_statements( + SordIter* files = lilv_world_find_statements( world, world->model, plugin_node, world->rdfs_seealso_node, NULL, NULL); FOREACH_MATCH(files) { - LilvNode file_node = lilv_match_object(files); + const SordNode* file_node = lilv_match_object(files); lilv_array_append(plugin->data_uris, lilv_value_new_from_node(world, file_node)); } @@ -386,17 +386,17 @@ lilv_world_load_dyn_manifest(LilvWorld* world, LV2_Dyn_Manifest_Handle handle = NULL; // ?dman a dynman:DynManifest - LilvMatches dmanifests = lilv_world_find_statements( + SordIter* dmanifests = lilv_world_find_statements( world, world->model, NULL, world->rdf_a_node, world->dyn_manifest_node, bundle_node); FOREACH_MATCH(dmanifests) { - LilvNode dmanifest = lilv_match_subject(dmanifests); + const SordNode* dmanifest = lilv_match_subject(dmanifests); // ?dman lv2:binary ?binary - LilvMatches binaries = lilv_world_find_statements( + SordIter* binaries = lilv_world_find_statements( world, world->model, dmanifest, world->lv2_binary_node, @@ -410,9 +410,9 @@ lilv_world_load_dyn_manifest(LilvWorld* world, } // Get binary path - LilvNode binary = lilv_match_object(binaries); - const uint8_t* lib_uri = sord_node_get_string(binary); - const char* lib_path = lilv_uri_to_path((const char*)lib_uri); + const SordNode* binary = lilv_match_object(binaries); + const uint8_t* lib_uri = sord_node_get_string(binary); + const char* lib_path = lilv_uri_to_path((const char*)lib_uri); if (!lib_path) { LILV_ERROR("No dynamic manifest library path\n"); continue; @@ -457,14 +457,14 @@ lilv_world_load_dyn_manifest(LilvWorld* world, fclose(fd); // ?plugin a lv2:Plugin - LilvMatches plug_results = lilv_world_find_statements( + SordIter* plug_results = lilv_world_find_statements( world, world->model, NULL, world->rdf_a_node, world->lv2_plugin_node, bundle_node); FOREACH_MATCH(plug_results) { - LilvNode plugin_node = lilv_match_subject(plug_results); + const SordNode* plugin_node = lilv_match_subject(plug_results); lilv_world_add_plugin(world, plugin_node, &manifest_uri, binary, bundle_node); } @@ -495,14 +495,14 @@ lilv_world_load_bundle(LilvWorld* world, LilvValue* bundle_uri) lilv_world_blank_node_prefix(world)); // ?plugin a lv2:Plugin - LilvMatches plug_results = lilv_world_find_statements( + SordIter* plug_results = lilv_world_find_statements( world, world->model, NULL, world->rdf_a_node, world->lv2_plugin_node, bundle_node); FOREACH_MATCH(plug_results) { - LilvNode plugin_node = lilv_match_subject(plug_results); + const SordNode* plugin_node = lilv_match_subject(plug_results); lilv_world_add_plugin(world, plugin_node, &manifest_uri, NULL, bundle_node); } @@ -511,14 +511,14 @@ lilv_world_load_bundle(LilvWorld* world, LilvValue* bundle_uri) lilv_world_load_dyn_manifest(world, bundle_node, manifest_uri); // ?specification a lv2:Specification - LilvMatches spec_results = lilv_world_find_statements( + SordIter* spec_results = lilv_world_find_statements( world, world->model, NULL, world->rdf_a_node, world->lv2_specification_node, bundle_node); FOREACH_MATCH(spec_results) { - LilvNode spec = lilv_match_subject(spec_results); + const SordNode* spec = lilv_match_subject(spec_results); lilv_world_add_spec(world, spec, bundle_node); } lilv_match_end(spec_results); @@ -672,17 +672,17 @@ lilv_world_load_plugin_classes(LilvWorld* world) a menu), they won't be seen anyway... */ - LilvMatches classes = lilv_world_find_statements( + SordIter* classes = lilv_world_find_statements( world, world->model, NULL, world->rdf_a_node, world->rdfs_class_node, NULL); FOREACH_MATCH(classes) { - LilvNode class_node = lilv_match_subject(classes); + const SordNode* class_node = lilv_match_subject(classes); // Get parents (superclasses) - LilvMatches parents = lilv_world_find_statements( + SordIter* parents = lilv_world_find_statements( world, world->model, class_node, world->rdfs_subclassof_node, @@ -694,7 +694,7 @@ lilv_world_load_plugin_classes(LilvWorld* world) continue; } - LilvNode parent_node = lilv_match_object(parents); + const SordNode* parent_node = lilv_match_object(parents); lilv_match_end(parents); if (!sord_node_get_type(parent_node) == SORD_URI) { @@ -703,7 +703,7 @@ lilv_world_load_plugin_classes(LilvWorld* world) } // Get labels - LilvMatches labels = lilv_world_find_statements( + SordIter* labels = lilv_world_find_statements( world, world->model, class_node, world->rdfs_label_node, @@ -715,7 +715,7 @@ lilv_world_load_plugin_classes(LilvWorld* world) continue; } - LilvNode label_node = lilv_match_object(labels); + const SordNode* label_node = lilv_match_object(labels); const uint8_t* label = (const uint8_t*)sord_node_get_string(label_node); lilv_match_end(labels); @@ -746,7 +746,7 @@ lilv_world_load_all(LilvWorld* world) const LilvValue* plugin_uri = lilv_plugin_get_uri(plugin); // ?new dc:replaces plugin - LilvMatches replacement = lilv_world_find_statements( + SordIter* replacement = lilv_world_find_statements( world, world->model, NULL, world->dc_replaces_node, -- cgit v1.2.1