Minor code cleanups, slightly reduce LOC.

git-svn-id: http://svn.drobilla.net/lad/trunk/lilv@5416 a436a847-0d15-0410-975c-d299462d15a1

1 files changed, 145 insertions, 290 deletions

diff --git a/lilv/lilv.h b/lilv/lilv.h
index 7de90d4..b86a884 100644
--- a/lilv/lilv.h
+++ b/lilv/lilv.h
@@ -106,16 +106,14 @@ typedef void LilvNodes;          /**< set<Node>. */
    Return value is shared and must not be deleted by caller.
    @return @a uri converted to a path, or NULL on failure (URI is not local).
 */
-LILV_API
-const char*
+LILV_API const char*
 lilv_uri_to_path(const char* uri);
 
 /**
    Create a new URI value.
    Returned value must be freed by caller with lilv_node_free.
 */
-LILV_API
-LilvNode*
+LILV_API LilvNode*
 lilv_new_uri(LilvWorld* world, const char* uri);
 
 /**
@@ -127,62 +125,54 @@ lilv_new_uri(LilvWorld* world, const char* uri);
    Relative paths are resolved against the current working directory.  Note
    that this may yield unexpected results if @p host is another machine.
 */
-LILV_API
-LilvNode*
+LILV_API LilvNode*
 lilv_new_file_uri(LilvWorld* world, const char* host, const char* path);
 
 /**
    Create a new string value (with no language).
    Returned value must be freed by caller with lilv_node_free.
 */
-LILV_API
-LilvNode*
+LILV_API LilvNode*
 lilv_new_string(LilvWorld* world, const char* str);
 
 /**
    Create a new integer value.
    Returned value must be freed by caller with lilv_node_free.
 */
-LILV_API
-LilvNode*
+LILV_API LilvNode*
 lilv_new_int(LilvWorld* world, int val);
 
 /**
    Create a new floating point value.
    Returned value must be freed by caller with lilv_node_free.
 */
-LILV_API
-LilvNode*
+LILV_API LilvNode*
 lilv_new_float(LilvWorld* world, float val);
 
 /**
    Create a new boolean value.
    Returned value must be freed by caller with lilv_node_free.
 */
-LILV_API
-LilvNode*
+LILV_API LilvNode*
 lilv_new_bool(LilvWorld* world, bool val);
 
 /**
    Free a LilvNode.
    It is safe to call this function on NULL.
 */
-LILV_API
-void
+LILV_API void
 lilv_node_free(LilvNode* val);
 
 /**
    Duplicate a LilvNode.
 */
-LILV_API
-LilvNode*
+LILV_API LilvNode*
 lilv_node_duplicate(const LilvNode* val);
 
 /**
    Return whether two values are equivalent.
 */
-LILV_API
-bool
+LILV_API bool
 lilv_node_equals(const LilvNode* value, const LilvNode* other);
 
 /**
@@ -198,15 +188,13 @@ lilv_node_equals(const LilvNode* value, const LilvNode* other);
    <tr><th>Boolean</td><td>true</td></tr>
    </table>
 */
-LILV_API
-char*
+LILV_API char*
 lilv_node_get_turtle_token(const LilvNode* value);
 
 /**
    Return whether the value is a URI (resource).
 */
-LILV_API
-bool
+LILV_API bool
 lilv_node_is_uri(const LilvNode* value);
 
 /**
@@ -214,15 +202,13 @@ lilv_node_is_uri(const LilvNode* value);
    Valid to call only if lilv_node_is_uri(@a value) returns true.
    Returned value is owned by @a value and must not be freed by caller.
 */
-LILV_API
-const char*
+LILV_API const char*
 lilv_node_as_uri(const LilvNode* value);
 
 /**
    Return whether the value is a blank node (resource with no URI).
 */
-LILV_API
-bool
+LILV_API bool
 lilv_node_is_blank(const LilvNode* value);
 
 /**
@@ -230,38 +216,33 @@ lilv_node_is_blank(const LilvNode* value);
    Valid to call only if lilv_node_is_blank(@a value) returns true.
    Returned value is owned by @a value and must not be freed by caller.
 */
-LILV_API
-const char*
+LILV_API const char*
 lilv_node_as_blank(const LilvNode* value);
 
 /**
    Return whether this value is a literal (i.e. not a URI).
    Returns true if @a value is a string or numeric value.
 */
-LILV_API
-bool
+LILV_API bool
 lilv_node_is_literal(const LilvNode* value);
 
 /**
    Return whether this value is a string literal.
    Returns true if @a value is a string value (and not numeric).
 */
-LILV_API
-bool
+LILV_API bool
 lilv_node_is_string(const LilvNode* value);
 
 /**
    Return @a value as a string.
 */
-LILV_API
-const char*
+LILV_API const char*
 lilv_node_as_string(const LilvNode* value);
 
 /**
    Return whether this value is a decimal literal.
 */
-LILV_API
-bool
+LILV_API bool
 lilv_node_is_float(const LilvNode* value);
 
 /**
@@ -269,38 +250,33 @@ lilv_node_is_float(const LilvNode* value);
    Valid to call only if lilv_node_is_float(@a value) or
    lilv_node_is_int(@a value) returns true.
 */
-LILV_API
-float
+LILV_API float
 lilv_node_as_float(const LilvNode* value);
 
 /**
    Return whether this value is an integer literal.
 */
-LILV_API
-bool
+LILV_API bool
 lilv_node_is_int(const LilvNode* value);
 
 /**
    Return @a value as an integer.
    Valid to call only if lilv_node_is_int(@a value) returns true.
 */
-LILV_API
-int
+LILV_API int
 lilv_node_as_int(const LilvNode* value);
 
 /**
    Return whether this value is a boolean.
 */
-LILV_API
-bool
+LILV_API bool
 lilv_node_is_bool(const LilvNode* value);
 
 /**
    Return @a value as a bool.
    Valid to call only if lilv_node_is_bool(@a value) returns true.
 */
-LILV_API
-bool
+LILV_API bool
 lilv_node_as_bool(const LilvNode* value);
 
 /**
@@ -343,28 +319,22 @@ lilv_node_as_bool(const LilvNode* value);
 
 /* LilvPluginClasses */
 
-LILV_API
-void
+LILV_API void
 lilv_plugin_classes_free(LilvPluginClasses* collection);
 
-LILV_API
-unsigned
+LILV_API unsigned
 lilv_plugin_classes_size(const LilvPluginClasses* collection);
 
-LILV_API
-LilvIter*
+LILV_API LilvIter*
 lilv_plugin_classes_begin(const LilvPluginClasses* collection);
 
-LILV_API
-const LilvPluginClass*
+LILV_API const LilvPluginClass*
 lilv_plugin_classes_get(const LilvPluginClasses* collection, LilvIter* i);
 
-LILV_API
-LilvIter*
+LILV_API LilvIter*
 lilv_plugin_classes_next(const LilvPluginClasses* collection, LilvIter* i);
 
-LILV_API
-bool
+LILV_API bool
 lilv_plugin_classes_is_end(const LilvPluginClasses* collection, LilvIter* i);
 
 /**
@@ -373,61 +343,48 @@ lilv_plugin_classes_is_end(const LilvPluginClasses* collection, LilvIter* i);
    modified by the caller in any way.
    @return NULL if no plugin class with @a uri is found in @a classes.
 */
-LILV_API
-const LilvPluginClass*
+LILV_API const LilvPluginClass*
 lilv_plugin_classes_get_by_uri(const LilvPluginClasses* classes,
                                const LilvNode*          uri);
 
 /* ScalePoints */
 
-LILV_API
-void
+LILV_API void
 lilv_scale_points_free(LilvScalePoints* collection);
 
-LILV_API
-unsigned
+LILV_API unsigned
 lilv_scale_points_size(const LilvScalePoints* collection);
 
-LILV_API
-LilvIter*
+LILV_API LilvIter*
 lilv_scale_points_begin(const LilvScalePoints* collection);
 
-LILV_API
-const LilvScalePoint*
+LILV_API const LilvScalePoint*
 lilv_scale_points_get(const LilvScalePoints* collection, LilvIter* i);
 
-LILV_API
-LilvIter*
+LILV_API LilvIter*
 lilv_scale_points_next(const LilvScalePoints* collection, LilvIter* i);
 
-LILV_API
-bool
+LILV_API bool
 lilv_scale_points_is_end(const LilvScalePoints* collection, LilvIter* i);
 
 /* UIs */
 
-LILV_API
-void
+LILV_API void
 lilv_uis_free(LilvUIs* collection);
 
-LILV_API
-unsigned
+LILV_API unsigned
 lilv_uis_size(const LilvUIs* collection);
 
-LILV_API
-LilvIter*
+LILV_API LilvIter*
 lilv_uis_begin(const LilvUIs* collection);
 
-LILV_API
-const LilvUI*
+LILV_API const LilvUI*
 lilv_uis_get(const LilvUIs* collection, LilvIter* i);
 
-LILV_API
-LilvIter*
+LILV_API LilvIter*
 lilv_uis_next(const LilvUIs* collection, LilvIter* i);
 
-LILV_API
-bool
+LILV_API bool
 lilv_uis_is_end(const LilvUIs* collection, LilvIter* i);
 
 /**
@@ -436,75 +393,60 @@ lilv_uis_is_end(const LilvUIs* collection, LilvIter* i);
    modified by the caller in any way.
    @return NULL if no UI with @a uri is found in @a list.
 */
-LILV_API
-const LilvUI*
+LILV_API const LilvUI*
 lilv_uis_get_by_uri(const LilvUIs*  uis,
                     const LilvNode* uri);
 
 /* Nodes */
 
-LILV_API
-void
+LILV_API void
 lilv_nodes_free(LilvNodes* collection);
 
-LILV_API
-unsigned
+LILV_API unsigned
 lilv_nodes_size(const LilvNodes* collection);
 
-LILV_API
-LilvIter*
+LILV_API LilvIter*
 lilv_nodes_begin(const LilvNodes* collection);
 
-LILV_API
-const LilvNode*
+LILV_API const LilvNode*
 lilv_nodes_get(const LilvNodes* collection, LilvIter* i);
 
-LILV_API
-LilvIter*
+LILV_API LilvIter*
 lilv_nodes_next(const LilvNodes* collection, LilvIter* i);
 
-LILV_API
-bool
+LILV_API bool
 lilv_nodes_is_end(const LilvNodes* collection, LilvIter* i);
 
-LILV_API
-LilvNode*
+LILV_API LilvNode*
 lilv_nodes_get_first(const LilvNodes* collection);
 
 /**
    Return whether @a values contains @a value.
 */
-LILV_API
-bool
+LILV_API bool
 lilv_nodes_contains(const LilvNodes* values, const LilvNode* value);
 
 /**
    Return a new LilvNodes that contains all nodes from both @p a and @p b.
 */
-LILV_API
-LilvNodes*
+LILV_API LilvNodes*
 lilv_nodes_merge(const LilvNodes* a, const LilvNodes* b);
 
 /* Plugins */
 
-LILV_API
-unsigned
+LILV_API unsigned
 lilv_plugins_size(const LilvPlugins* collection);
 
-LILV_API
-LilvIter*
+LILV_API LilvIter*
 lilv_plugins_begin(const LilvPlugins* collection);
 
-LILV_API
-const LilvPlugin*
+LILV_API const LilvPlugin*
 lilv_plugins_get(const LilvPlugins* collection, LilvIter* i);
 
-LILV_API
-LilvIter*
+LILV_API LilvIter*
 lilv_plugins_next(const LilvPlugins* collection, LilvIter* i);
 
-LILV_API
-bool
+LILV_API bool
 lilv_plugins_is_end(const LilvPlugins* collection, LilvIter* i);
 
 /**
@@ -513,8 +455,7 @@ lilv_plugins_is_end(const LilvPlugins* collection, LilvIter* i);
    modified by the caller in any way.
    @return NULL if no plugin with @a uri is found in @a plugins.
 */
-LILV_API
-const LilvPlugin*
+LILV_API const LilvPlugin*
 lilv_plugins_get_by_uri(const LilvPlugins* plugins,
                         const LilvNode*    uri);
 
@@ -532,8 +473,7 @@ lilv_plugins_get_by_uri(const LilvPlugins* plugins,
    Initialize a new, empty world.
    If initialization fails, NULL is returned.
 */
-LILV_API
-LilvWorld*
+LILV_API LilvWorld*
 lilv_world_new(void);
 
 /**
@@ -558,8 +498,7 @@ lilv_world_new(void);
    @ref LILV_OPTION_FILTER_LANG
    @ref LILV_OPTION_DYN_MANIFEST
 */
-LILV_API
-void
+LILV_API void
 lilv_world_set_option(LilvWorld*      world,
                       const char*     uri,
                       const LilvNode* value);
@@ -571,8 +510,7 @@ lilv_world_set_option(LilvWorld*      world,
    (e.g. instances of LilvPlugin).  Do not destroy the world until you are
    finished with all objects that came from it.
 */
-LILV_API
-void
+LILV_API void
 lilv_world_free(LilvWorld* world);
 
 /**
@@ -586,8 +524,7 @@ lilv_world_free(LilvWorld* world);
    in special circumstances (e.g. development utilities, or hosts that ship
    with special plugin bundles which are installed to a known location).
 */
-LILV_API
-void
+LILV_API void
 lilv_world_load_all(LilvWorld* world);
 
 /**
@@ -602,8 +539,7 @@ lilv_world_load_all(LilvWorld* world);
    unchanged between (or even during) program invocations. Plugins (among
    other things) MUST be identified by URIs (not paths) in save files.
 */
-LILV_API
-void
+LILV_API void
 lilv_world_load_bundle(LilvWorld* world,
                        LilvNode*  bundle_uri);
 
@@ -615,8 +551,7 @@ lilv_world_load_bundle(LilvWorld* world,
    have been separately loaded with liv_world_load_resource(), they must be
    separately unloaded with lilv_world_unload_resource().
 */
-LILV_API
-int
+LILV_API int
 lilv_world_unload_bundle(LilvWorld* world, LilvNode* bundle_uri);
 
 /**
@@ -627,8 +562,7 @@ lilv_world_unload_bundle(LilvWorld* world, LilvNode* bundle_uri);
    All accessible data files linked to @c resource with rdfs:seeAlso will be
    loaded into the world model.
 */
-LILV_API
-int
+LILV_API int
 lilv_world_load_resource(LilvWorld*      world,
                          const LilvNode* resource);
 
@@ -639,24 +573,21 @@ lilv_world_load_resource(LilvWorld*      world,
    This unloads all data loaded by a previous call to
    lilv_world_load_resource() with the given @c resource.
 */
-LILV_API
-int
+LILV_API int
 lilv_world_unload_resource(LilvWorld*      world,
                            const LilvNode* resource);
 
 /**
    Get the parent of all other plugin classes, lv2:Plugin.
 */
-LILV_API
-const LilvPluginClass*
+LILV_API const LilvPluginClass*
 lilv_world_get_plugin_class(const LilvWorld* world);
 
 /**
    Return a list of all found plugin classes.
    Returned list is owned by world and must not be freed by the caller.
 */
-LILV_API
-const LilvPluginClasses*
+LILV_API const LilvPluginClasses*
 lilv_world_get_plugin_classes(const LilvWorld* world);
 
 /**
@@ -670,8 +601,7 @@ lilv_world_get_plugin_classes(const LilvWorld* world);
    The returned list and the plugins it contains are owned by @a world
    and must not be freed by caller.
 */
-LILV_API
-const LilvPlugins*
+LILV_API const LilvPlugins*
 lilv_world_get_all_plugins(const LilvWorld* world);
 
 /**
@@ -679,8 +609,7 @@ lilv_world_get_all_plugins(const LilvWorld* world);
    Either @c subject or @c object may be NULL (i.e. a wildcard), but not both.
    @return All matches for the wildcard field, or NULL.
 */
-LILV_API
-LilvNodes*
+LILV_API LilvNodes*
 lilv_world_find_nodes(LilvWorld*      world,
                       const LilvNode* subject,
                       const LilvNode* predicate,
@@ -694,8 +623,7 @@ lilv_world_find_nodes(LilvWorld*      world,
    case of only wanting a single value.
    @return the first matching node, or NULL if no matches are found.
 */
-LILV_API
-LilvNode*
+LILV_API LilvNode*
 lilv_world_get(LilvWorld*      world,
                const LilvNode* subject,
                const LilvNode* predicate,
@@ -711,8 +639,7 @@ lilv_world_get(LilvWorld*      world,
    @param predicate Predicate (key) of statement, or NULL for anything.
    @param object Object (value) of statement, or NULL for anything.
 */
-LILV_API
-bool
+LILV_API bool
 lilv_world_ask(LilvWorld*      world,
                const LilvNode* subject,
                const LilvNode* predicate,
@@ -734,8 +661,7 @@ lilv_world_ask(LilvWorld*      world,
    testing utilities, etc.
    @return true iff @a plugin is valid.
 */
-LILV_API
-bool
+LILV_API bool
 lilv_plugin_verify(const LilvPlugin* plugin);
 
 /**
@@ -752,8 +678,7 @@ lilv_plugin_verify(const LilvPlugin* plugin);
 
    @return A shared URI value which must not be modified or freed.
 */
-LILV_API
-const LilvNode*
+LILV_API const LilvNode*
 lilv_plugin_get_uri(const LilvPlugin* plugin);
 
 /**
@@ -767,8 +692,7 @@ lilv_plugin_get_uri(const LilvPlugin* plugin);
    filesystem path, use lilv_uri_to_path.
    @return a shared string which must not be modified or freed.
 */
-LILV_API
-const LilvNode*
+LILV_API const LilvNode*
 lilv_plugin_get_bundle_uri(const LilvPlugin* plugin);
 
 /**
@@ -779,8 +703,7 @@ lilv_plugin_get_bundle_uri(const LilvPlugin* plugin);
    @return a list of complete URLs eg. "file:///foo/ABundle.lv2/aplug.ttl",
    which is shared and must not be modified or freed.
 */
-LILV_API
-const LilvNodes*
+LILV_API const LilvNodes*
 lilv_plugin_get_data_uris(const LilvPlugin* plugin);
 
 /**
@@ -789,8 +712,7 @@ lilv_plugin_get_data_uris(const LilvPlugin* plugin);
    filesystem path, use lilv_uri_to_path.
    @return a shared string which must not be modified or freed.
 */
-LILV_API
-const LilvNode*
+LILV_API const LilvNode*
 lilv_plugin_get_library_uri(const LilvPlugin* plugin);
 
 /**
@@ -800,15 +722,13 @@ lilv_plugin_get_library_uri(const LilvPlugin* plugin);
    as a plugin identifier (use the URI for that).
    Returned value must be freed by the caller.
 */
-LILV_API
-LilvNode*
+LILV_API LilvNode*
 lilv_plugin_get_name(const LilvPlugin* plugin);
 
 /**
    Get the class this plugin belongs to (e.g. Filters).
 */
-LILV_API
-const LilvPluginClass*
+LILV_API const LilvPluginClass*
 lilv_plugin_get_class(const LilvPlugin* plugin);
 
 /**
@@ -823,8 +743,7 @@ lilv_plugin_get_class(const LilvPlugin* plugin);
    sensibly represented as a LilvNodes (e.g. blank nodes).
    Return value must be freed by caller with lilv_nodes_free.
 */
-LILV_API
-LilvNodes*
+LILV_API LilvNodes*
 lilv_plugin_get_value(const LilvPlugin* p,
                       const LilvNode*   predicate);
 
@@ -833,8 +752,7 @@ lilv_plugin_get_value(const LilvPlugin* p,
    This will return true if the feature is an optional or required feature
    of the plugin.
 */
-LILV_API
-bool
+LILV_API bool
 lilv_plugin_has_feature(const LilvPlugin* p,
                         const LilvNode*   feature_uri);
 
@@ -848,8 +766,7 @@ lilv_plugin_has_feature(const LilvPlugin* p,
 
    Returned value must be freed by caller with lilv_nodes_free.
 */
-LILV_API
-LilvNodes*
+LILV_API LilvNodes*
 lilv_plugin_get_supported_features(const LilvPlugin* p);
 
 /**
@@ -863,8 +780,7 @@ lilv_plugin_get_supported_features(const LilvPlugin* p);
 
    Return value must be freed by caller with lilv_nodes_free.
 */
-LILV_API
-LilvNodes*
+LILV_API LilvNodes*
 lilv_plugin_get_required_features(const LilvPlugin* p);
 
 /**
@@ -875,15 +791,13 @@ lilv_plugin_get_required_features(const LilvPlugin* p);
 
    Return value must be freed by caller with lilv_nodes_free.
 */
-LILV_API
-LilvNodes*
+LILV_API LilvNodes*
 lilv_plugin_get_optional_features(const LilvPlugin* p);
 
 /**
    Return whether or not a plugin provides a specific extension data.
 */
-LILV_API
-bool
+LILV_API bool
 lilv_plugin_has_extension_data(const LilvPlugin* p,
                                const LilvNode*   uri);
 
@@ -892,15 +806,13 @@ lilv_plugin_has_extension_data(const LilvPlugin* p,
    This can be used to find which URIs lilv_instance_get_extension_data()
    will return a value for without instantiating the plugin.
 */
-LILV_API
-LilvNodes*
+LILV_API LilvNodes*
 lilv_plugin_get_extension_data(const LilvPlugin* p);
 
 /**
    Get the number of ports on this plugin.
 */
-LILV_API
-uint32_t
+LILV_API uint32_t
 lilv_plugin_get_num_ports(const LilvPlugin* p);
 
 /**
@@ -917,8 +829,7 @@ lilv_plugin_get_num_ports(const LilvPlugin* p);
    all float ports on a plugin, and may be significantly faster than
    repeated calls to lilv_port_get_range.
 */
-LILV_API
-void
+LILV_API void
 lilv_plugin_get_port_ranges_float(const LilvPlugin* p,
                                   float*            min_values,
                                   float*            max_values,
@@ -930,8 +841,7 @@ lilv_plugin_get_port_ranges_float(const LilvPlugin* p,
    desired can be found quickly.  REMEMBER TO TERMINATE THE PARAMETER LIST
    OF THIS FUNCTION WITH NULL OR VERY NASTY THINGS WILL HAPPEN.
 */
-LILV_API
-uint32_t
+LILV_API uint32_t
 lilv_plugin_get_num_ports_of_class(const LilvPlugin* p,
                                    const LilvNode*   class_1, ...);
 
@@ -941,8 +851,7 @@ lilv_plugin_get_num_ports_of_class(const LilvPlugin* p,
 
    This function calls va_arg() on @p args but does not call va_end().
 */
-LILV_API
-uint32_t
+LILV_API uint32_t
 lilv_plugin_get_num_ports_of_class_va(const LilvPlugin* p,
                                       const LilvNode*   class_1,
                                       va_list           args);
@@ -953,8 +862,7 @@ lilv_plugin_get_num_ports_of_class_va(const LilvPlugin* p,
    The index of the latency port can be found with lilv_plugin_get_latency_port
    ONLY if this function returns true.
 */
-LILV_API
-bool
+LILV_API bool
 lilv_plugin_has_latency(const LilvPlugin* p);
 
 /**
@@ -966,15 +874,13 @@ lilv_plugin_has_latency(const LilvPlugin* p);
    (by hosts with the ability/need) MUST provide this port, which is a control
    rate output port that reports the latency for each cycle in frames.
 */
-LILV_API
-uint32_t
+LILV_API uint32_t
 lilv_plugin_get_latency_port_index(const LilvPlugin* p);
 
 /**
    Get a port on @a plugin by @a index.
 */
-LILV_API
-const LilvPort*
+LILV_API const LilvPort*
 lilv_plugin_get_port_by_index(const LilvPlugin* plugin,
                               uint32_t          index);
 
@@ -983,8 +889,7 @@ lilv_plugin_get_port_by_index(const LilvPlugin* plugin,
    Note this function is slower than lilv_plugin_get_port_by_index,
    especially on plugins with a very large number of ports.
 */
-LILV_API
-const LilvPort*
+LILV_API const LilvPort*
 lilv_plugin_get_port_by_symbol(const LilvPlugin* plugin,
                                const LilvNode*   symbol);
 
@@ -998,8 +903,7 @@ lilv_plugin_get_port_by_symbol(const LilvPlugin* plugin,
    ports for a particular designation.  If @a port_class is NULL, any port
    with the given designation will be returned.
 */
-LILV_API
-const LilvPort*
+LILV_API const LilvPort*
 lilv_plugin_get_port_by_designation(const LilvPlugin* plugin,
                                     const LilvNode*   port_class,
                                     const LilvNode*   designation);
@@ -1010,8 +914,7 @@ lilv_plugin_get_port_by_designation(const LilvPlugin* plugin,
    More information about the project can be read via lilv_world_find_nodes(),
    typically using properties from DOAP (e.g. doap:name).
 */
-LILV_API
-LilvNode*
+LILV_API LilvNode*
 lilv_plugin_get_project(const LilvPlugin* plugin);
 
 /**
@@ -1019,8 +922,7 @@ lilv_plugin_get_project(const LilvPlugin* plugin);
    Returns NULL if author name is not present.
    Returned value must be freed by caller.
 */
-LILV_API
-LilvNode*
+LILV_API LilvNode*
 lilv_plugin_get_author_name(const LilvPlugin* plugin);
 
 /**
@@ -1028,8 +930,7 @@ lilv_plugin_get_author_name(const LilvPlugin* plugin);
    Returns NULL if author email address is not present.
    Returned value must be freed by caller.
 */
-LILV_API
-LilvNode*
+LILV_API LilvNode*
 lilv_plugin_get_author_email(const LilvPlugin* plugin);
 
 /**
@@ -1037,8 +938,7 @@ lilv_plugin_get_author_email(const LilvPlugin* plugin);
    Returns NULL if author homepage is not present.
    Returned value must be freed by caller.
 */
-LILV_API
-LilvNode*
+LILV_API LilvNode*
 lilv_plugin_get_author_homepage(const LilvPlugin* plugin);
 
 /**
@@ -1047,8 +947,7 @@ lilv_plugin_get_author_homepage(const LilvPlugin* plugin);
    The plugin will still be usable, but hosts should hide them from their
    user interfaces to prevent users from using deprecated plugins.
 */
-LILV_API
-bool
+LILV_API bool
 lilv_plugin_is_replaced(const LilvPlugin* plugin);
 
 /**
@@ -1057,8 +956,7 @@ lilv_plugin_is_replaced(const LilvPlugin* plugin);
    This function is particularly useful for porting plugins in conjunction with
    an LV2 bridge such as NASPRO.
 */
-LILV_API
-void
+LILV_API void
 lilv_plugin_write_description(LilvWorld*        world,
                               const LilvPlugin* plugin,
                               const LilvNode*   base_uri,
@@ -1070,8 +968,7 @@ lilv_plugin_write_description(LilvWorld*        world,
    This function is intended for use with lilv_plugin_write_description to
    write a complete description of a plugin to a bundle.
 */
-LILV_API
-void
+LILV_API void
 lilv_plugin_write_manifest_entry(LilvWorld*        world,
                                  const LilvPlugin* plugin,
                                  const LilvNode*   base_uri,
@@ -1091,8 +988,7 @@ lilv_plugin_write_manifest_entry(LilvWorld*        world,
    To actually load the data for each returned resource, use
    lilv_world_load_resource.
 */
-LILV_API
-LilvNodes*
+LILV_API LilvNodes*
 lilv_plugin_get_related(const LilvPlugin* plugin, const LilvNode* type);
 
 /**
@@ -1108,16 +1004,14 @@ lilv_plugin_get_related(const LilvPlugin* plugin, const LilvNode* type);
 
    @return A shared node which must not be modified or freed.
 */
-LILV_API
-const LilvNode*
+LILV_API const LilvNode*
 lilv_port_get_node(const LilvPlugin* plugin,
                    const LilvPort*   port);
 
 /**
    Port analog of lilv_plugin_get_value.
 */
-LILV_API
-LilvNodes*
+LILV_API LilvNodes*
 lilv_port_get_value(const LilvPlugin* plugin,
                     const LilvPort*   port,
                     const LilvNode*   predicate);
@@ -1129,8 +1023,7 @@ lilv_port_get_value(const LilvPlugin* plugin,
    simpler to use in the common case of only caring about one value.  The
    caller is responsible for freeing the returned node.
 */
-LILV_API
-LilvNode*
+LILV_API LilvNode*
 lilv_port_get(const LilvPlugin* plugin,
               const LilvPort*   port,
               const LilvNode*   predicate);
@@ -1138,16 +1031,14 @@ lilv_port_get(const LilvPlugin* plugin,
 /**
    Return the LV2 port properties of a port.
 */
-LILV_API
-LilvNodes*
+LILV_API LilvNodes*
 lilv_port_get_properties(const LilvPlugin* plugin,
                          const LilvPort*   port);
 
 /**
    Return whether a port has a certain property.
 */
-LILV_API
-bool
+LILV_API bool
 lilv_port_has_property(const LilvPlugin* p,
                        const LilvPort*   port,
                        const LilvNode*   property_uri);
@@ -1158,8 +1049,7 @@ lilv_port_has_property(const LilvPlugin* p,
    More precisely, this returns true iff the port has an atom:supports or an
    ev:supportsEvent property with @p event_type as the value.
 */
-LILV_API
-bool
+LILV_API bool
 lilv_port_supports_event(const LilvPlugin* p,
                          const LilvPort*   port,
                          const LilvNode*   event_type);
@@ -1169,8 +1059,7 @@ lilv_port_supports_event(const LilvPlugin* p,
    The index is only valid for the life of the plugin and may change between
    versions.  For a stable identifier, use the symbol.
 */
-LILV_API
-uint32_t
+LILV_API uint32_t
 lilv_port_get_index(const LilvPlugin* plugin,
                     const LilvPort*   port);
 
@@ -1179,8 +1068,7 @@ lilv_port_get_index(const LilvPlugin* plugin,
    The 'symbol' is a short string, a valid C identifier.
    Returned value is owned by @a port and must not be freed.
 */
-LILV_API
-const LilvNode*
+LILV_API const LilvNode*
 lilv_port_get_symbol(const LilvPlugin* plugin,
                      const LilvPort*   port);
 
@@ -1190,8 +1078,7 @@ lilv_port_get_symbol(const LilvPlugin* plugin,
    data file without a language tag).  Returned value must be freed by
    the caller.
 */
-LILV_API
-LilvNode*
+LILV_API LilvNode*
 lilv_port_get_name(const LilvPlugin* plugin,
                    const LilvPort*   port);
 
@@ -1202,8 +1089,7 @@ lilv_port_get_name(const LilvPlugin* plugin,
    The returned list does not include lv2:Port, which is implied.
    Returned value is shared and must not be destroyed by caller.
 */
-LILV_API
-const LilvNodes*
+LILV_API const LilvNodes*
 lilv_port_get_classes(const LilvPlugin* plugin,
                       const LilvPort*   port);
 
@@ -1215,8 +1101,7 @@ lilv_port_get_classes(const LilvPlugin* plugin,
    this function is designed so that Lilv is usable with any port types
    without requiring explicit support in Lilv.
 */
-LILV_API
-bool
+LILV_API bool
 lilv_port_is_a(const LilvPlugin* plugin,
                const LilvPort*   port,
                const LilvNode*   port_class);
@@ -1229,8 +1114,7 @@ lilv_port_is_a(const LilvPlugin* plugin,
    be freed by the caller using lilv_node_free), or NULL if the value does not
    exist.
 */
-LILV_API
-void
+LILV_API void
 lilv_port_get_range(const LilvPlugin* plugin,
                     const LilvPort*   port,
                     LilvNode**        deflt,
@@ -1244,8 +1128,7 @@ lilv_port_get_range(const LilvPlugin* plugin,
    Returned value may be NULL if @a port has no scale points, otherwise it
    must be freed by caller with lilv_scale_points_free.
 */
-LILV_API
-LilvScalePoints*
+LILV_API LilvScalePoints*
 lilv_port_get_scale_points(const LilvPlugin* plugin,
                            const LilvPort*   port);
 
@@ -1262,8 +1145,7 @@ lilv_port_get_scale_points(const LilvPlugin* plugin,
    @param subject The subject of the state description (e.g. a preset URI).
    @return A new LilvState which must be freed with lilv_state_free(), or NULL.
 */
-LILV_API
-LilvState*
+LILV_API LilvState*
 lilv_state_new_from_world(LilvWorld*      world,
                           LV2_URID_Map*   map,
                           const LilvNode* subject);
@@ -1281,8 +1163,7 @@ lilv_state_new_from_world(LilvWorld*      world,
    parse the file into the world model, i.e. the returned state is the only
    new memory consumed once this function returns.
 */
-LILV_API
-LilvState*
+LILV_API LilvState*
 lilv_state_new_from_file(LilvWorld*      world,
                          LV2_URID_Map*   map,
                          const LilvNode* subject,
@@ -1291,8 +1172,7 @@ lilv_state_new_from_file(LilvWorld*      world,
 /**
    Load a state snapshot from a string made by lilv_state_to_string().
 */
-LILV_API
-LilvState*
+LILV_API LilvState*
 lilv_state_new_from_string(LilvWorld*    world,
                            LV2_URID_Map* map,
                            const char*   str);
@@ -1369,8 +1249,7 @@ typedef const void* (*LilvGetPortValueFunc)(const char* port_symbol,
    See <a href="http://lv2plug.in/ns/ext/state/state.h">state.h</a> from the
    LV2 State extension for details on the @c flags and @c features parameters.
 */
-LILV_API
-LilvState*
+LILV_API LilvState*
 lilv_state_new_from_instance(const LilvPlugin*          plugin,
                              LilvInstance*              instance,
                              LV2_URID_Map*              map,
@@ -1386,43 +1265,37 @@ lilv_state_new_from_instance(const LilvPlugin*          plugin,
 /**
    Free @c state.
 */
-LILV_API
-void
+LILV_API void
 lilv_state_free(LilvState* state);
 
 /**
    Return true iff @c a is equivalent to @c b.
 */
-LILV_API
-bool
+LILV_API bool
 lilv_state_equals(const LilvState* a, const LilvState* b);
 
 /**
    Return the number of properties in @c state.
 */
-LILV_API
-unsigned
+LILV_API unsigned
 lilv_state_get_num_properties(const LilvState* state);
 
 /**
    Get the URI of the plugin @c state applies to.
 */
-LILV_API
-const LilvNode*
+LILV_API const LilvNode*
 lilv_state_get_plugin_uri(const LilvState* state);
 
 /**
    Get the label of @c state.
 */
-LILV_API
-const char*
+LILV_API const char*
 lilv_state_get_label(const LilvState* state);
 
 /**
    Set the label of @c state.
 */
-LILV_API
-void
+LILV_API void
 lilv_state_set_label(LilvState*  state,
                      const char* label);
 
@@ -1462,8 +1335,7 @@ typedef void (*LilvSetPortValueFunc)(const char* port_symbol,
    See <a href="http://lv2plug.in/ns/ext/state/state.h">state.h</a> from the
    LV2 State extension for details on the @c flags and @c features parameters.
 */
-LILV_API
-void
+LILV_API void
 lilv_state_restore(const LilvState*           state,
                    LilvInstance*              instance,
                    LilvSetPortValueFunc       set_value,
@@ -1486,8 +1358,7 @@ lilv_state_restore(const LilvState*           state,
    If @c uri is NULL, the preset URI will be a file URI, but the bundle
    can safely be moved (i.e. the state file will use "<>" as the subject).
 */
-LILV_API
-int
+LILV_API int
 lilv_state_save(LilvWorld*                 world,
                 LV2_URID_Map*              map,
                 LV2_URID_Unmap*            unmap,
@@ -1504,8 +1375,7 @@ lilv_state_save(LilvWorld*                 world,
    doing, pass NULL for this, otherwise the state may not be restorable via
    lilv_state_new_from_string().
 */
-LILV_API
-char*
+LILV_API char*
 lilv_state_to_string(LilvWorld*       world,
                      LV2_URID_Map*    map,
                      LV2_URID_Unmap*  unmap,
@@ -1523,16 +1393,14 @@ lilv_state_to_string(LilvWorld*       world,
    Get the label of this scale point (enumeration value)
    Returned value is owned by @a point and must not be freed.
 */
-LILV_API
-const LilvNode*
+LILV_API const LilvNode*
 lilv_scale_point_get_label(const LilvScalePoint* point);
 
 /**
    Get the value of this scale point (enumeration value)
    Returned value is owned by @a point and must not be freed.
 */
-LILV_API
-const LilvNode*
+LILV_API const LilvNode*
 lilv_scale_point_get_value(const LilvScalePoint* point);
 
 /**
@@ -1546,32 +1414,28 @@ lilv_scale_point_get_value(const LilvScalePoint* point);
    Returned value is owned by @a plugin_class and must not be freed by caller.
    Returned value may be NULL, if class has no parent.
 */
-LILV_API
-const LilvNode*
+LILV_API const LilvNode*
 lilv_plugin_class_get_parent_uri(const LilvPluginClass* plugin_class);
 
 /**
    Get the URI of this plugin class.
    Returned value is owned by @a plugin_class and must not be freed by caller.
 */
-LILV_API
-const LilvNode*
+LILV_API const LilvNode*
 lilv_plugin_class_get_uri(const LilvPluginClass* plugin_class);
 
 /**
    Get the label of this plugin class, ie "Oscillators".
    Returned value is owned by @a plugin_class and must not be freed by caller.
 */
-LILV_API
-const LilvNode*
+LILV_API const LilvNode*
 lilv_plugin_class_get_label(const LilvPluginClass* plugin_class);
 
 /**
    Get the subclasses of this plugin class.
    Returned value must be freed by caller with lilv_plugin_classes_free.
 */
-LILV_API
-LilvPluginClasses*
+LILV_API LilvPluginClasses*
 lilv_plugin_class_get_children(const LilvPluginClass* plugin_class);
 
 /**
@@ -1610,8 +1474,7 @@ struct LilvInstanceImpl {
    NULL may be passed if the host supports no additional features.
    @return NULL if instantiation failed.
 */
-LILV_API
-LilvInstance*
+LILV_API LilvInstance*
 lilv_plugin_instantiate(const LilvPlugin*        plugin,
                         double                   sample_rate,
                         const LV2_Feature*const* features);
@@ -1621,8 +1484,7 @@ lilv_plugin_instantiate(const LilvPlugin*        plugin,
    It is safe to call this function on NULL.
    @a instance is invalid after this call.
 */
-LILV_API
-void
+LILV_API void
 lilv_instance_free(LilvInstance* instance);
 
 #ifndef LILV_INTERNAL
@@ -1741,8 +1603,7 @@ lilv_instance_get_handle(const LilvInstance* instance)
    Get all UIs for @a plugin.
    Returned value must be freed by caller using lilv_uis_free.
 */
-LILV_API
-LilvUIs*
+LILV_API LilvUIs*
 lilv_plugin_get_uis(const LilvPlugin* plugin);
 
 /**
@@ -1750,8 +1611,7 @@ lilv_plugin_get_uis(const LilvPlugin* plugin);
    @param ui The Plugin UI
    @return a shared value which must not be modified or freed.
 */
-LILV_API
-const LilvNode*
+LILV_API const LilvNode*
 lilv_ui_get_uri(const LilvUI* ui);
 
 /**
@@ -1762,8 +1622,7 @@ lilv_ui_get_uri(const LilvUI* ui);
    Note that in most cases lilv_ui_is_supported should be used which finds the
    UI type, avoding the need to use this function (and type specific logic).
 */
-LILV_API
-const LilvNodes*
+LILV_API const LilvNodes*
 lilv_ui_get_classes(const LilvUI* ui);
 
 /**
@@ -1771,8 +1630,7 @@ lilv_ui_get_classes(const LilvUI* ui);
    @param ui        The Plugin UI
    @param class_uri The URI of the LV2 UI type to check this UI against
 */
-LILV_API
-bool
+LILV_API bool
 lilv_ui_is_a(const LilvUI* ui, const LilvNode* class_uri);
 
 /**
@@ -1793,8 +1651,7 @@ typedef unsigned (*LilvUISupportedFunc)(const char* container_type_uri,
    which is owned by @c ui and must not be freed by the caller.
    @return The embedding quality level returned by @c supported_func.
 */
-LILV_API
-unsigned
+LILV_API unsigned
 lilv_ui_is_supported(const LilvUI*       ui,
                      LilvUISupportedFunc supported_func,
                      const LilvNode*     container_type,
@@ -1805,8 +1662,7 @@ lilv_ui_is_supported(const LilvUI*       ui,
    @param ui The Plugin UI
    @return a shared value which must not be modified or freed.
 */
-LILV_API
-const LilvNode*
+LILV_API const LilvNode*
 lilv_ui_get_bundle_uri(const LilvUI* ui);
 
 /**
@@ -1814,8 +1670,7 @@ lilv_ui_get_bundle_uri(const LilvUI* ui);
    @param ui The Plugin UI
    @return a shared value which must not be modified or freed.
 */
-LILV_API
-const LilvNode*
+LILV_API const LilvNode*
 lilv_ui_get_binary_uri(const LilvUI* ui);
 
 /**