Updated LV2 revision number.

Fixed formatting in lv2.h.
Better/terser comment for lv2:Specification in lv2.ttl.
Implemented LV2 specification discovery.


git-svn-id: http://svn.drobilla.net/lad/slv2@673 a436a847-0d15-0410-975c-d299462d15a1

4 files changed, 285 insertions, 182 deletions

diff --git a/data/lv2.ttl b/data/lv2.ttl
index 38888bd..c842489 100644
--- a/data/lv2.ttl
+++ b/data/lv2.ttl
@@ -1,5 +1,5 @@
 # RDF Schema for LV2 plugins
-# *** PROVISIONAL Revision 2007-07-23 ***
+# *** PROVISIONAL Revision 2007-08-03 ***
 #
 # This document describes the classes and properties that are defined by the
 # core LV2 specification.  See <http://lv2plug.in> for more information.
@@ -33,10 +33,10 @@
 
 :Specification a rdfs:Class ;
 	rdfs:comment """
-A part of the system LV2 specification.  This file defines the core of the LV2
-specification, but extensions can be written which add to it.  Specification
-data is distributed in bundles so hosts may discover all present extensions
-and treat them as a single extended "LV2 Specification".
+An LV2 specification (ie this specification, or an LV2 extension).
+
+Specification data, like plugins, is distributed in standardized
+bundles so hosts may discover all present LV2 data.
 See http://lv2plug.in/docs for more details.
 """ .
 
@@ -50,7 +50,7 @@ See http://lv2plug.in/docs for more details.
    doap:programming-language "C" ;
    doap:release [
        doap:revision "1.0beta4" ;
-       doap:created "2007-07-23"
+       doap:created "2007-08-03"
    ] ;
    doap:maintainer [
        a foaf:Person ;
@@ -72,7 +72,7 @@ See http://lv2plug.in/docs for more details.
 :Plugin a rdfs:Class ;
     rdfs:label   "Plugin" ;
     rdfs:comment """
-The class that represents an LV2 plugin.
+The class which represents an LV2 plugin.
 
 To be used by a host a Plugin must have at least the following properties:
     rdf:type (with object :Plugin)
diff --git a/slv2/lv2.h b/slv2/lv2.h
index d00d2fb..1e73905 100644
--- a/slv2/lv2.h
+++ b/slv2/lv2.h
@@ -36,7 +36,7 @@ extern "C" {
 
 /** @file lv2.h
  *
- * Revision: 1.0beta3
+ * Revision: 1.0beta4
  *
  * == Overview ==
  *
@@ -159,175 +159,175 @@ typedef struct _LV2_Host_Feature {
  * of functions to instantiate it, link it to buffers and run it. */
 typedef struct _LV2_Descriptor { 
 
-  /** A globally unique, case-sensitive identifier for this plugin type.
-   *
-   * All plugins with the same URI MUST be compatible in terms of 'port
-   * signature', meaning they have the same number of ports, same port
-   * shortnames, and roughly the same functionality.  URIs should
-   * probably contain a version number (or similar) for this reason.
-   *
-   * Rationale:  When serializing session/patch/etc files, hosts MUST
-   * refer to a loaded plugin by the plugin URI only.  In the future
-   * loading a plugin with this URI MUST yield a plugin with the
-   * same ports (etc) which is 100% compatible. */
-  const char * URI;
-
-  /** Function pointer that instantiates a plugin.
-   *
-   * A handle is returned indicating the new plugin instance. The
-   * instantiation function accepts a sample rate as a parameter as well
-   * as the plugin descriptor from which this instantiate function was
-   * found. This function must return NULL if instantiation fails.
-   *
-   * BundlePath is a string of the path to the LV2 bundle which contains
-   * this plugin binary.  It MUST include the trailing directory separator
-   * (e.g. '/') so that BundlePath + filename gives the path to a file
-   * in the bundle.
-   *
-   * HostFeatures is a NULL terminated array of the URIs of the LV2
-   * features that the host supports. Plugins may refuse to instantiate
-   * if required features are not found here (however hosts SHOULD NOT use
-   * this as a discovery mechanism, instead reading the data file before
-   * attempting to instantiate the plugin).  This array must always exist;
-   * if a host has no features, it MUST pass a single element array
-   * containing NULL (to simplify plugins).
-   *
-   * Note that instance initialisation should generally occur in
-   * activate() rather than here.  If a host calls instantiate, it MUST
-   * call cleanup() at some point in the future. */
-  LV2_Handle (*instantiate)(const struct _LV2_Descriptor *  Descriptor,
-                            uint32_t                        SampleRate,
-                            const char *                    BundlePath,
-                            const LV2_Host_Feature *const * HostFeatures);
-
-  /** Function pointer that connects a port on a plugin instance to a memory
-   * location where the block of data for the port will be read/written.
-   *
-   * The data location is expected to be of the type defined in the
-   * plugin's data file (e.g. an array of float for an lv2:AudioPort).
-   * Memory issues are managed by the host. The plugin must read/write
-   * the data at these locations every time run() is called, data
-   * present at the time of this connection call MUST NOT be
-   * considered meaningful.
-   *
-   * connect_port() may be called more than once for a plugin instance
-   * to allow the host to change the buffers that the plugin is reading
-   * or writing. These calls may be made before or after activate()
-   * or deactivate() calls.  Note that there may be realtime constraints
-   * on connect_port (see lv2:hardRTCapable in lv2.ttl).
-   *
-   * connect_port() MUST be called at least once for each port before
-   * run() is called.  The plugin must pay careful attention to the block
-   * size passed to the run function as the block allocated may only just
-   * be large enough to contain the block of data (typically samples), and
-   * is not guaranteed to be constant.
-   *
-   * Plugin writers should be aware that the host may elect to use the
-   * same buffer for more than one port and even use the same buffer for
-   * both input and output (see lv2:inPlaceBroken in lv2.ttl).
-   * However, overlapped buffers or use of a single buffer for both
-   * audio and control data may result in unexpected behaviour.
-   *
-   * If the plugin has the property lv2:hardRTCapable then there are 
-   * various things that the plugin MUST NOT do within the connect_port()
-   * function (see lv2.ttl). */
-  void (*connect_port)(LV2_Handle Instance,
-                       uint32_t   Port,
-                       void *     DataLocation);
-
-  /** Function pointer that initialises a plugin instance and activates
-   * it for use.
-   * 
-   * This is separated from instantiate() to aid real-time support and so
-   * that hosts can reinitialise a plugin instance by calling deactivate()
-   * and then activate(). In this case the plugin instance must reset all
-   * state information dependent on the history of the plugin instance
-   * except for any data locations provided by connect_port(). If there
-   * is nothing for activate() to do then the plugin writer may provide
-   * a NULL rather than an empty function.
-   *
-   * When present, hosts MUST call this function once before run()
-   * is called for the first time. This call SHOULD be made as close
-   * to the run() call as possible and indicates to real-time plugins
-   * that they are now live, however plugins MUST NOT rely on a prompt
-   * call to run() after activate().  activate() may not be called again
-   * unless deactivate() is called first (after which activate() may be
-   * called again, followed by deactivate, etc. etc.).  If a host calls
-   * activate, it MUST call deactivate at some point in the future.
-   *
-   * Note that connect_port() may be called before or after a call to
-   * activate(). */
-  void (*activate)(LV2_Handle Instance);
-
-  /** Function pointer that runs a plugin instance for a block.
-   *
-   * Two parameters are required: the first is a handle to the particular
-   * instance to be run and the second indicates the block size (in
-   * samples) for which the plugin instance may run.
-   *
-   * Note that if an activate() function exists then it must be called
-   * before run(). If deactivate() is called for a plugin instance then
-   * the plugin instance may not be reused until activate() has been
-   * called again.
-   *
-   * If the plugin has the property lv2:hardRTCapable then there are 
-   * various things that the plugin MUST NOT do within the run()
-   * function (see lv2.ttl). */
-  void (*run)(LV2_Handle Instance,
-              uint32_t   SampleCount);
-
-  /** This is the counterpart to activate() (see above). If there is
-   * nothing for deactivate() to do then the plugin writer may provide
-   * a NULL rather than an empty function.
-   *
-   * Hosts must deactivate all activated units after they have been run()
-   * for the last time. This call SHOULD be made as close to the last
-   * run() call as possible and indicates to real-time plugins that
-   * they are no longer live, however plugins MUST NOT rely on prompt
-   * deactivation. Note that connect_port() may be called before or
-   * after a call to deactivate().
-   *
-   * Note that deactivation is not similar to pausing as the plugin
-   * instance will be reinitialised when activate() is called to reuse it.
-   * Hosts MUST NOT call deactivate() unless activate() was previously
-   * called. */
-  void (*deactivate)(LV2_Handle Instance);
-
-  /** This is the counterpart to instantiate() (see above).  Once an instance
-   * of a plugin has been finished with it can be deleted using this
-   * function. The instance handle passed ceases to be valid after
-   * this call.
-   * 
-   * If activate() was called for a plugin instance then a corresponding
-   * call to deactivate() MUST be made before cleanup() is called.
-   * Hosts MUST NOT call cleanup() unless instantiate() was previously
-   * called. */
-  void (*cleanup)(LV2_Handle Instance);
-    
-  /** Function pointer that can be used to return additional instance data for
-   * a plugin defined by some extenion (e.g. a struct containing additional
-   * function pointers).
-   *
-   * The actual type and meaning of the returned object MUST be specified 
-   * precisely by the extension if it defines any extra data.  If a particular
-   * extension does not define extra instance data, this function MUST return
-   * NULL for that extension's URI.  If a plugin does not support any
-   * extensions that define extra instance data, this function pointer may be
-   * set to NULL rather than providing an empty function.
-   * 
-   * The only parameter is the URI of the extension. The plugin MUST return
-   * NULL if it does not support the extension, but hosts SHOULD NOT use this
-   * as a discovery method (e.g. hosts should only call this function for
-   * extensions known to be supported by the plugin from the data file).
-   * 
-   * NOTE: It is highly recommended that this function returns a struct, and
-   * NOT a direct function pointer.  Standard C++ (for real reasons) does not
-   * allow type casts from void* to a function pointer type.  To provide
-   * additional functions a struct should be returned containing the extra
-   * function pointers (which is valid standard C++, and a much better idea
-   * for extensibility anyway).
-   */
-  void* (*extension_data)(const char * URI); 
+	/** A globally unique, case-sensitive identifier for this plugin type.
+	 *
+	 * All plugins with the same URI MUST be compatible in terms of 'port
+	 * signature', meaning they have the same number of ports, same port
+	 * shortnames, and roughly the same functionality.  URIs should
+	 * probably contain a version number (or similar) for this reason.
+	 *
+	 * Rationale:  When serializing session/patch/etc files, hosts MUST
+	 * refer to a loaded plugin by the plugin URI only.  In the future
+	 * loading a plugin with this URI MUST yield a plugin with the
+	 * same ports (etc) which is 100% compatible. */
+	const char * URI;
+
+	/** Function pointer that instantiates a plugin.
+	 *
+	 * A handle is returned indicating the new plugin instance. The
+	 * instantiation function accepts a sample rate as a parameter as well
+	 * as the plugin descriptor from which this instantiate function was
+	 * found. This function must return NULL if instantiation fails.
+	 *
+	 * BundlePath is a string of the path to the LV2 bundle which contains
+	 * this plugin binary.  It MUST include the trailing directory separator
+	 * (e.g. '/') so that BundlePath + filename gives the path to a file
+	 * in the bundle.
+	 *
+	 * HostFeatures is a NULL terminated array of the URIs of the LV2
+	 * features that the host supports. Plugins may refuse to instantiate
+	 * if required features are not found here (however hosts SHOULD NOT use
+	 * this as a discovery mechanism, instead reading the data file before
+	 * attempting to instantiate the plugin).  This array must always exist;
+	 * if a host has no features, it MUST pass a single element array
+	 * containing NULL (to simplify plugins).
+	 *
+	 * Note that instance initialisation should generally occur in
+	 * activate() rather than here.  If a host calls instantiate, it MUST
+	 * call cleanup() at some point in the future. */
+	LV2_Handle (*instantiate)(const struct _LV2_Descriptor *  Descriptor,
+	                          double                          SampleRate,
+	                          const char *                    BundlePath,
+	                          const LV2_Host_Feature *const * HostFeatures);
+
+	/** Function pointer that connects a port on a plugin instance to a memory
+	 * location where the block of data for the port will be read/written.
+	 *
+	 * The data location is expected to be of the type defined in the
+	 * plugin's data file (e.g. an array of float for an lv2:AudioPort).
+	 * Memory issues are managed by the host. The plugin must read/write
+	 * the data at these locations every time run() is called, data
+	 * present at the time of this connection call MUST NOT be
+	 * considered meaningful.
+	 *
+	 * connect_port() may be called more than once for a plugin instance
+	 * to allow the host to change the buffers that the plugin is reading
+	 * or writing. These calls may be made before or after activate()
+	 * or deactivate() calls.  Note that there may be realtime constraints
+	 * on connect_port (see lv2:hardRTCapable in lv2.ttl).
+	 *
+	 * connect_port() MUST be called at least once for each port before
+	 * run() is called.  The plugin must pay careful attention to the block
+	 * size passed to the run function as the block allocated may only just
+	 * be large enough to contain the block of data (typically samples), and
+	 * is not guaranteed to be constant.
+	 *
+	 * Plugin writers should be aware that the host may elect to use the
+	 * same buffer for more than one port and even use the same buffer for
+	 * both input and output (see lv2:inPlaceBroken in lv2.ttl).
+	 * However, overlapped buffers or use of a single buffer for both
+	 * audio and control data may result in unexpected behaviour.
+	 *
+	 * If the plugin has the property lv2:hardRTCapable then there are 
+	 * various things that the plugin MUST NOT do within the connect_port()
+	 * function (see lv2.ttl). */
+	void (*connect_port)(LV2_Handle Instance,
+	                     uint32_t   Port,
+	                     void *     DataLocation);
+
+	/** Function pointer that initialises a plugin instance and activates
+	 * it for use.
+	 * 
+	 * This is separated from instantiate() to aid real-time support and so
+	 * that hosts can reinitialise a plugin instance by calling deactivate()
+	 * and then activate(). In this case the plugin instance must reset all
+	 * state information dependent on the history of the plugin instance
+	 * except for any data locations provided by connect_port(). If there
+	 * is nothing for activate() to do then the plugin writer may provide
+	 * a NULL rather than an empty function.
+	 *
+	 * When present, hosts MUST call this function once before run()
+	 * is called for the first time. This call SHOULD be made as close
+	 * to the run() call as possible and indicates to real-time plugins
+	 * that they are now live, however plugins MUST NOT rely on a prompt
+	 * call to run() after activate().  activate() may not be called again
+	 * unless deactivate() is called first (after which activate() may be
+	 * called again, followed by deactivate, etc. etc.).  If a host calls
+	 * activate, it MUST call deactivate at some point in the future.
+	 *
+	 * Note that connect_port() may be called before or after a call to
+	 * activate(). */
+	void (*activate)(LV2_Handle Instance);
+
+	/** Function pointer that runs a plugin instance for a block.
+	 *
+	 * Two parameters are required: the first is a handle to the particular
+	 * instance to be run and the second indicates the block size (in
+	 * samples) for which the plugin instance may run.
+	 *
+	 * Note that if an activate() function exists then it must be called
+	 * before run(). If deactivate() is called for a plugin instance then
+	 * the plugin instance may not be reused until activate() has been
+	 * called again.
+	 *
+	 * If the plugin has the property lv2:hardRTCapable then there are 
+	 * various things that the plugin MUST NOT do within the run()
+	 * function (see lv2.ttl). */
+	void (*run)(LV2_Handle Instance,
+	            uint32_t   SampleCount);
+
+	/** This is the counterpart to activate() (see above). If there is
+	 * nothing for deactivate() to do then the plugin writer may provide
+	 * a NULL rather than an empty function.
+	 *
+	 * Hosts must deactivate all activated units after they have been run()
+	 * for the last time. This call SHOULD be made as close to the last
+	 * run() call as possible and indicates to real-time plugins that
+	 * they are no longer live, however plugins MUST NOT rely on prompt
+	 * deactivation. Note that connect_port() may be called before or
+	 * after a call to deactivate().
+	 *
+	 * Note that deactivation is not similar to pausing as the plugin
+	 * instance will be reinitialised when activate() is called to reuse it.
+	 * Hosts MUST NOT call deactivate() unless activate() was previously
+	 * called. */
+	void (*deactivate)(LV2_Handle Instance);
+
+	/** This is the counterpart to instantiate() (see above).  Once an instance
+	 * of a plugin has been finished with it can be deleted using this
+	 * function. The instance handle passed ceases to be valid after
+	 * this call.
+	 * 
+	 * If activate() was called for a plugin instance then a corresponding
+	 * call to deactivate() MUST be made before cleanup() is called.
+	 * Hosts MUST NOT call cleanup() unless instantiate() was previously
+	 * called. */
+	void (*cleanup)(LV2_Handle Instance);
+
+	/** Function pointer that can be used to return additional instance data for
+	 * a plugin defined by some extenion (e.g. a struct containing additional
+	 * function pointers).
+	 *
+	 * The actual type and meaning of the returned object MUST be specified 
+	 * precisely by the extension if it defines any extra data.  If a particular
+	 * extension does not define extra instance data, this function MUST return
+	 * NULL for that extension's URI.  If a plugin does not support any
+	 * extensions that define extra instance data, this function pointer may be
+	 * set to NULL rather than providing an empty function.
+	 * 
+	 * The only parameter is the URI of the extension. The plugin MUST return
+	 * NULL if it does not support the extension, but hosts SHOULD NOT use this
+	 * as a discovery method (e.g. hosts should only call this function for
+	 * extensions known to be supported by the plugin from the data file).
+	 * 
+	 * NOTE: It is highly recommended that this function returns a struct, and
+	 * NOT a direct function pointer.  Standard C++ (for real reasons) does not
+	 * allow type casts from void* to a function pointer type.  To provide
+	 * additional functions a struct should be returned containing the extra
+	 * function pointers (which is valid standard C++, and a much better idea
+	 * for extensibility anyway).
+	 */
+	void* (*extension_data)(const char * URI); 
 
 } LV2_Descriptor;
 
diff --git a/src/slv2_internal.h b/src/slv2_internal.h
index f7999e9..bb538f6 100644
--- a/src/slv2_internal.h
+++ b/src/slv2_internal.h
@@ -143,6 +143,7 @@ struct _SLV2World {
 	librdf_parser*    parser;
 	SLV2PluginClasses plugin_classes;
 	SLV2Plugins       plugins;
+	librdf_node*      lv2_specification_node;
 	librdf_node*      lv2_plugin_node;
 	librdf_node*      rdf_a_node;
 
@@ -171,6 +172,13 @@ void
 slv2_world_load_path(SLV2World   world,
                      const char* search_path);
 
+	
+void
+slv2_world_load_specifications(SLV2World world);
+
+void
+slv2_world_load_file(SLV2World world, librdf_uri* file_uri);
+
 
 /* ********* GUI ********* */
 
diff --git a/src/world.c b/src/world.c
index e2b3574..0c6ad77 100644
--- a/src/world.c
+++ b/src/world.c
@@ -65,6 +65,9 @@ slv2_world_new()
 	
 	world->plugins = slv2_plugins_new();
 	
+	world->lv2_specification_node = librdf_new_node_from_uri_string(world->world,
+			(unsigned char*)"http://lv2plug.in/ns/lv2core#Specification");
+	
 	world->lv2_plugin_node = librdf_new_node_from_uri_string(world->world,
 			(unsigned char*)"http://lv2plug.in/ns/lv2core#Plugin");
 	
@@ -117,6 +120,9 @@ slv2_world_new_using_rdf_world(librdf_world* rdf_world)
 	
 	world->plugins = slv2_plugins_new();
 	
+	world->lv2_specification_node = librdf_new_node_from_uri_string(world->world,
+			(unsigned char*)"http://lv2plug.in/ns/lv2core#Specification");
+	
 	world->lv2_plugin_node = librdf_new_node_from_uri_string(rdf_world,
 			(unsigned char*)"http://lv2plug.in/ns/lv2core#Plugin");
 	
@@ -142,6 +148,7 @@ slv2_world_free(SLV2World world)
 	if (world->rdf_lock)
 		world->rdf_lock(world->rdf_lock_data);
 
+	librdf_free_node(world->lv2_specification_node);
 	librdf_free_node(world->lv2_plugin_node);
 	librdf_free_node(world->rdf_a_node);
 
@@ -217,6 +224,22 @@ slv2_world_unlock_if_necessary(SLV2World world)
 }
 
 
+/** Load the entire contents of a file into the world model.
+ */
+void
+slv2_world_load_file(SLV2World world, librdf_uri* file_uri)
+{
+	slv2_world_lock_if_necessary(world);
+
+	//printf("LOADING FILE: %s\n", librdf_uri_as_string(file_uri));
+
+	librdf_parser_parse_into_model(world->parser, file_uri, NULL, world->model);
+	
+	slv2_world_unlock_if_necessary(world);
+}
+
+
+
 void
 slv2_world_load_bundle(SLV2World world, const char* bundle_uri_str)
 {
@@ -247,7 +270,7 @@ slv2_world_load_bundle(SLV2World world, const char* bundle_uri_str)
 
 		librdf_node* plugin_node = librdf_new_node_from_node(librdf_statement_get_subject(s));
 
-		/* Add ?plugin rdfs:seeAlso "datafile.ttl" */
+		/* Add ?plugin rdfs:seeAlso <manifest.ttl>*/
 		librdf_node* subject = plugin_node;
 		librdf_node* predicate = librdf_new_node_from_uri_string(world->world, 
 				(unsigned char*)"http://www.w3.org/2000/01/rdf-schema#seeAlso");
@@ -256,7 +279,7 @@ slv2_world_load_bundle(SLV2World world, const char* bundle_uri_str)
 
 		librdf_model_add(world->model, subject, predicate, object);
 		
-		/* Add ?plugin slv2:bundleURI "file://some/path" */
+		/* Add ?plugin slv2:bundleURI <file://some/path> */
 		subject = librdf_new_node_from_node(plugin_node);
 		predicate = librdf_new_node_from_uri_string(world->world, 
 				(unsigned char*)"http://drobilla.net/ns/slv2#bundleURI");
@@ -269,6 +292,41 @@ slv2_world_load_bundle(SLV2World world, const char* bundle_uri_str)
 	
 	librdf_free_stream(results);
 	
+	/* Query statement: ?specification a lv2:Specification */
+	q = librdf_new_statement_from_nodes(world->world,
+			NULL, world->rdf_a_node, world->lv2_specification_node);
+
+	results = librdf_model_find_statements(manifest_model, q);
+
+	while (!librdf_stream_end(results)) {
+		librdf_statement* s = librdf_stream_get_object(results);
+
+		librdf_node* spec_node = librdf_new_node_from_node(librdf_statement_get_subject(s));
+
+		/* Add ?specification rdfs:seeAlso <manifest.ttl> */
+		librdf_node* subject = spec_node;
+		librdf_node* predicate = librdf_new_node_from_uri_string(world->world, 
+				(unsigned char*)"http://www.w3.org/2000/01/rdf-schema#seeAlso");
+		librdf_node* object = librdf_new_node_from_uri(world->world,
+				manifest_uri);
+		
+		//printf("SPEC: %s\n", librdf_uri_as_string(librdf_node_get_uri(subject)));
+
+		librdf_model_add(world->model, subject, predicate, object);
+		
+		/* Add ?specification slv2:bundleURI <file://some/path> */
+		subject = librdf_new_node_from_node(spec_node);
+		predicate = librdf_new_node_from_uri_string(world->world, 
+				(unsigned char*)"http://drobilla.net/ns/slv2#bundleURI");
+		object = librdf_new_node_from_uri(world->world, bundle_uri);
+
+		librdf_model_add(world->model, subject, predicate, object);
+
+		librdf_stream_next(results);
+	}
+	
+	librdf_free_stream(results);
+	
 	/* Join the temporary model to the main model */
 	librdf_stream* manifest_stream = librdf_model_as_stream(manifest_model);
 	librdf_model_add_statements(world->model, manifest_stream);
@@ -351,6 +409,41 @@ slv2_plugin_compare_by_uri(const void* a, const void* b)
 }
 */
 
+void
+slv2_world_load_specifications(SLV2World world)
+{
+	unsigned char* query_string = (unsigned char*)
+    	"PREFIX : <http://lv2plug.in/ns/lv2core#>\n"
+		"PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n"
+		"SELECT DISTINCT ?spec ?data WHERE {\n"
+		"	?spec a            :Specification ;\n"
+		"         rdfs:seeAlso ?data .\n"
+		"}\n";
+	
+	librdf_query* q = librdf_new_query(world->world, "sparql", NULL, query_string, NULL);
+	
+	librdf_query_results* results = librdf_query_execute(q, world->model);
+
+	while (!librdf_query_results_finished(results)) {
+		librdf_node* spec_node  = librdf_query_results_get_binding_value(results, 0);
+		librdf_uri*  spec_uri   = librdf_node_get_uri(spec_node);
+		librdf_node* data_node = librdf_query_results_get_binding_value(results, 1);
+		librdf_uri*  data_uri  = librdf_node_get_uri(data_node);
+
+		//printf("SPEC: %s / %s\n", librdf_uri_as_string(spec_uri), librdf_uri_as_string(data_uri));
+
+		slv2_world_load_file(world, data_uri);
+
+		librdf_free_node(spec_node);
+		librdf_free_node(data_node);
+
+		librdf_query_results_next(results);
+	}
+
+	librdf_free_query_results(results);
+	librdf_free_query(q);
+}
+
 
 void
 slv2_world_load_plugin_classes(SLV2World world)
@@ -364,8 +457,8 @@ slv2_world_load_plugin_classes(SLV2World world)
     	"PREFIX : <http://lv2plug.in/ns/lv2core#>\n"
 		"PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n"
 		"SELECT DISTINCT ?class ?parent ?label WHERE {\n"
-		//"	?plugin a :Plugin; a ?class .\n"
-		"	?class a rdfs:Class; rdfs:subClassOf ?parent; rdfs:label ?label\n"
+		//"	?plugin a ?class .\n"
+		"	?class a :Class; rdfs:subClassOf ?parent; rdfs:label ?label\n"
 		"} ORDER BY ?class\n";
 	
 	librdf_query* q = librdf_new_query(world->world, "sparql",
@@ -381,7 +474,7 @@ slv2_world_load_plugin_classes(SLV2World world)
 		librdf_node* label_node  = librdf_query_results_get_binding_value(results, 2);
 		const char*  label       = (const char*)librdf_node_get_literal_value(label_node);
 
-		//printf("CLASS: %s / %s\n", librdf_uri_as_string(parent_uri), librdf_uri_as_string(class_uri));
+		printf("CLASS: %s / %s\n", librdf_uri_as_string(parent_uri), librdf_uri_as_string(class_uri));
 		
 		SLV2PluginClass plugin_class = slv2_plugin_class_new(world,
 				(const char*)librdf_uri_as_string(parent_uri),
@@ -445,6 +538,8 @@ slv2_world_load_all(SLV2World world)
 	
 	/* 3. Query out things to cache */
 
+	slv2_world_load_specifications(world);
+
 	slv2_world_load_plugin_classes(world);
 
 	// Find all plugins and associated data files