Remove redundant LILV_API declarations

There are specified in the declarations in the public API header, there is no
need to duplicate them in the definitions.

10 files changed, 130 insertions, 130 deletions

diff --git a/src/collections.c b/src/collections.c
index 1142f1f..8a25eaa 100644
--- a/src/collections.c
+++ b/src/collections.c
@@ -106,7 +106,7 @@ lilv_plugin_classes_new(void)
 
 /* URI based accessors (for collections of things with URIs) */
 
-LILV_API const LilvPluginClass*
+const LilvPluginClass*
 lilv_plugin_classes_get_by_uri(const LilvPluginClasses* classes,
                                const LilvNode*          uri)
 {
@@ -114,7 +114,7 @@ lilv_plugin_classes_get_by_uri(const LilvPluginClasses* classes,
 		(const ZixTree*)classes, uri);
 }
 
-LILV_API const LilvUI*
+const LilvUI*
 lilv_uis_get_by_uri(const LilvUIs* uis, const LilvNode* uri)
 {
 	return (LilvUI*)lilv_collection_get_by_uri((const ZixTree*)uis, uri);
@@ -128,7 +128,7 @@ lilv_plugins_new(void)
 	return lilv_collection_new(lilv_header_compare_by_uri, NULL);
 }
 
-LILV_API const LilvPlugin*
+const LilvPlugin*
 lilv_plugins_get_by_uri(const LilvPlugins* plugins, const LilvNode* uri)
 {
 	return (LilvPlugin*)lilv_collection_get_by_uri(
@@ -137,7 +137,7 @@ lilv_plugins_get_by_uri(const LilvPlugins* plugins, const LilvNode* uri)
 
 /* Nodes */
 
-LILV_API bool
+bool
 lilv_nodes_contains(const LilvNodes* nodes, const LilvNode* value)
 {
 	LILV_FOREACH(nodes, i, nodes) {
@@ -149,7 +149,7 @@ lilv_nodes_contains(const LilvNodes* nodes, const LilvNode* value)
 	return false;
 }
 
-LILV_API LilvNodes*
+LilvNodes*
 lilv_nodes_merge(const LilvNodes* a, const LilvNodes* b)
 {
 	LilvNodes* result = lilv_nodes_new();
@@ -170,31 +170,31 @@ lilv_nodes_merge(const LilvNodes* a, const LilvNodes* b)
 /* Iterator */
 
 #define LILV_COLLECTION_IMPL(prefix, CT, ET) \
-LILV_API \
+\
 unsigned \
 prefix##_size(const CT* collection) { \
 	return lilv_collection_size(collection); \
 } \
 \
-LILV_API \
+\
 LilvIter* \
 prefix##_begin(const CT* collection) { \
 	return lilv_collection_begin(collection); \
 } \
 \
-LILV_API \
+\
 const ET* \
 prefix##_get(const CT* collection, LilvIter* i) { \
 	return (ET*)lilv_collection_get(collection, i); \
 } \
 \
-LILV_API \
+\
 LilvIter* \
 prefix##_next(const CT* collection, LilvIter* i) { \
 	return zix_tree_iter_next((ZixTreeIter*)i); \
 } \
 \
-LILV_API \
+\
 bool \
 prefix##_is_end(const CT* collection, LilvIter* i) { \
 	return zix_tree_iter_is_end((ZixTreeIter*)i); \
@@ -206,27 +206,27 @@ LILV_COLLECTION_IMPL(lilv_uis, LilvUIs, LilvUI)
 LILV_COLLECTION_IMPL(lilv_nodes, LilvNodes, LilvNode)
 LILV_COLLECTION_IMPL(lilv_plugins, LilvPlugins, LilvPlugin)
 
-LILV_API void
+void
 lilv_plugin_classes_free(LilvPluginClasses* collection) {
 	lilv_collection_free(collection);
 }
 
-LILV_API void
+void
 lilv_scale_points_free(LilvScalePoints* collection) {
 	lilv_collection_free(collection);
 }
 
-LILV_API void
+void
 lilv_uis_free(LilvUIs* collection) {
 	lilv_collection_free(collection);
 }
 
-LILV_API void
+void
 lilv_nodes_free(LilvNodes* collection) {
 	lilv_collection_free(collection);
 }
 
-LILV_API LilvNode*
+LilvNode*
 lilv_nodes_get_first(const LilvNodes* collection) {
 	return (LilvNode*)lilv_collection_get(collection,
 	                                      lilv_collection_begin(collection));
diff --git a/src/instance.c b/src/instance.c
index 75c550c..a6d486f 100644
--- a/src/instance.c
+++ b/src/instance.c
@@ -25,7 +25,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-LILV_API LilvInstance*
+LilvInstance*
 lilv_plugin_instantiate(const LilvPlugin*        plugin,
                         double                   sample_rate,
                         const LV2_Feature*const* features)
@@ -100,7 +100,7 @@ lilv_plugin_instantiate(const LilvPlugin*        plugin,
 	return result;
 }
 
-LILV_API void
+void
 lilv_instance_free(LilvInstance* instance)
 {
 	if (!instance) {
diff --git a/src/node.c b/src/node.c
index 95f6a8c..6a6c4f6 100644
--- a/src/node.c
+++ b/src/node.c
@@ -151,13 +151,13 @@ lilv_node_new_from_node(LilvWorld* world, const SordNode* node)
 	return result;
 }
 
-LILV_API LilvNode*
+LilvNode*
 lilv_new_uri(LilvWorld* world, const char* uri)
 {
 	return lilv_node_new(world, LILV_VALUE_URI, uri);
 }
 
-LILV_API LilvNode*
+LilvNode*
 lilv_new_file_uri(LilvWorld* world, const char* host, const char* path)
 {
 	char*    abs_path = lilv_path_absolute(path);
@@ -170,13 +170,13 @@ lilv_new_file_uri(LilvWorld* world, const char* host, const char* path)
 	return ret;
 }
 
-LILV_API LilvNode*
+LilvNode*
 lilv_new_string(LilvWorld* world, const char* str)
 {
 	return lilv_node_new(world, LILV_VALUE_STRING, str);
 }
 
-LILV_API LilvNode*
+LilvNode*
 lilv_new_int(LilvWorld* world, int val)
 {
 	char str[32];
@@ -186,7 +186,7 @@ lilv_new_int(LilvWorld* world, int val)
 	return ret;
 }
 
-LILV_API LilvNode*
+LilvNode*
 lilv_new_float(LilvWorld* world, float val)
 {
 	char str[32];
@@ -196,7 +196,7 @@ lilv_new_float(LilvWorld* world, float val)
 	return ret;
 }
 
-LILV_API LilvNode*
+LilvNode*
 lilv_new_bool(LilvWorld* world, bool val)
 {
 	LilvNode* ret = lilv_node_new(world, LILV_VALUE_BOOL,
@@ -205,7 +205,7 @@ lilv_new_bool(LilvWorld* world, bool val)
 	return ret;
 }
 
-LILV_API LilvNode*
+LilvNode*
 lilv_node_duplicate(const LilvNode* val)
 {
 	if (!val) {
@@ -220,7 +220,7 @@ lilv_node_duplicate(const LilvNode* val)
 	return result;
 }
 
-LILV_API void
+void
 lilv_node_free(LilvNode* val)
 {
 	if (val) {
@@ -229,7 +229,7 @@ lilv_node_free(LilvNode* val)
 	}
 }
 
-LILV_API bool
+bool
 lilv_node_equals(const LilvNode* value, const LilvNode* other)
 {
 	if (value == NULL && other == NULL) {
@@ -257,7 +257,7 @@ lilv_node_equals(const LilvNode* value, const LilvNode* other)
 	return false; /* shouldn't get here */
 }
 
-LILV_API char*
+char*
 lilv_node_get_turtle_token(const LilvNode* value)
 {
 	const char* str    = (const char*)sord_node_get_string(value->node);
@@ -296,13 +296,13 @@ lilv_node_get_turtle_token(const LilvNode* value)
 	return result;
 }
 
-LILV_API bool
+bool
 lilv_node_is_uri(const LilvNode* value)
 {
 	return (value && value->type == LILV_VALUE_URI);
 }
 
-LILV_API const char*
+const char*
 lilv_node_as_uri(const LilvNode* value)
 {
 	return (lilv_node_is_uri(value)
@@ -310,13 +310,13 @@ lilv_node_as_uri(const LilvNode* value)
 	        : NULL);
 }
 
-LILV_API bool
+bool
 lilv_node_is_blank(const LilvNode* value)
 {
 	return (value && value->type == LILV_VALUE_BLANK);
 }
 
-LILV_API const char*
+const char*
 lilv_node_as_blank(const LilvNode* value)
 {
 	return (lilv_node_is_blank(value)
@@ -324,7 +324,7 @@ lilv_node_as_blank(const LilvNode* value)
 	        : NULL);
 }
 
-LILV_API bool
+bool
 lilv_node_is_literal(const LilvNode* value)
 {
 	if (!value) {
@@ -342,37 +342,37 @@ lilv_node_is_literal(const LilvNode* value)
 	}
 }
 
-LILV_API bool
+bool
 lilv_node_is_string(const LilvNode* value)
 {
 	return (value && value->type == LILV_VALUE_STRING);
 }
 
-LILV_API const char*
+const char*
 lilv_node_as_string(const LilvNode* value)
 {
 	return value ? (const char*)sord_node_get_string(value->node) : NULL;
 }
 
-LILV_API bool
+bool
 lilv_node_is_int(const LilvNode* value)
 {
 	return (value && value->type == LILV_VALUE_INT);
 }
 
-LILV_API int
+int
 lilv_node_as_int(const LilvNode* value)
 {
 	return lilv_node_is_int(value) ? value->val.int_val : 0;
 }
 
-LILV_API bool
+bool
 lilv_node_is_float(const LilvNode* value)
 {
 	return (value && value->type == LILV_VALUE_FLOAT);
 }
 
-LILV_API float
+float
 lilv_node_as_float(const LilvNode* value)
 {
 	if (lilv_node_is_float(value)) {
@@ -383,19 +383,19 @@ lilv_node_as_float(const LilvNode* value)
 	return NAN;
 }
 
-LILV_API bool
+bool
 lilv_node_is_bool(const LilvNode* value)
 {
 	return (value && value->type == LILV_VALUE_BOOL);
 }
 
-LILV_API bool
+bool
 lilv_node_as_bool(const LilvNode* value)
 {
 	return lilv_node_is_bool(value) ? value->val.bool_val : false;
 }
 
-LILV_API char*
+char*
 lilv_node_get_path(const LilvNode* value, char** hostname)
 {
 	if (lilv_node_is_uri(value)) {
diff --git a/src/plugin.c b/src/plugin.c
index e1567f4..534bd1e 100644
--- a/src/plugin.c
+++ b/src/plugin.c
@@ -375,19 +375,19 @@ lilv_plugin_load_if_necessary(const LilvPlugin* plugin)
 	}
 }
 
-LILV_API const LilvNode*
+const LilvNode*
 lilv_plugin_get_uri(const LilvPlugin* plugin)
 {
 	return plugin->plugin_uri;
 }
 
-LILV_API const LilvNode*
+const LilvNode*
 lilv_plugin_get_bundle_uri(const LilvPlugin* plugin)
 {
 	return plugin->bundle_uri;
 }
 
-LILV_API const LilvNode*
+const LilvNode*
 lilv_plugin_get_library_uri(const LilvPlugin* plugin)
 {
 	lilv_plugin_load_if_necessary((LilvPlugin*)plugin);
@@ -414,13 +414,13 @@ lilv_plugin_get_library_uri(const LilvPlugin* plugin)
 	return plugin->binary_uri;
 }
 
-LILV_API const LilvNodes*
+const LilvNodes*
 lilv_plugin_get_data_uris(const LilvPlugin* plugin)
 {
 	return plugin->data_uris;
 }
 
-LILV_API const LilvPluginClass*
+const LilvPluginClass*
 lilv_plugin_get_class(const LilvPlugin* plugin)
 {
 	lilv_plugin_load_if_necessary((LilvPlugin*)plugin);
@@ -469,7 +469,7 @@ lilv_plugin_get_value_internal(const LilvPlugin* plugin,
 		plugin->world, plugin->plugin_uri->node, predicate, NULL);
 }
 
-LILV_API bool
+bool
 lilv_plugin_verify(const LilvPlugin* plugin)
 {
 	lilv_plugin_load_if_necessary(plugin);
@@ -503,7 +503,7 @@ lilv_plugin_verify(const LilvPlugin* plugin)
 	return true;
 }
 
-LILV_API LilvNode*
+LilvNode*
 lilv_plugin_get_name(const LilvPlugin* plugin)
 {
 	LilvNodes* results = lilv_plugin_get_value_internal(
@@ -526,7 +526,7 @@ lilv_plugin_get_name(const LilvPlugin* plugin)
 	return ret;
 }
 
-LILV_API LilvNodes*
+LilvNodes*
 lilv_plugin_get_value(const LilvPlugin* plugin,
                       const LilvNode*   predicate)
 {
@@ -534,14 +534,14 @@ lilv_plugin_get_value(const LilvPlugin* plugin,
 	return lilv_world_find_nodes(plugin->world, plugin->plugin_uri, predicate, NULL);
 }
 
-LILV_API uint32_t
+uint32_t
 lilv_plugin_get_num_ports(const LilvPlugin* plugin)
 {
 	lilv_plugin_load_ports_if_necessary(plugin);
 	return plugin->num_ports;
 }
 
-LILV_API void
+void
 lilv_plugin_get_port_ranges_float(const LilvPlugin* plugin,
                                   float*            min_values,
                                   float*            max_values,
@@ -588,7 +588,7 @@ lilv_plugin_get_port_ranges_float(const LilvPlugin* plugin,
 	}
 }
 
-LILV_API uint32_t
+uint32_t
 lilv_plugin_get_num_ports_of_class_va(const LilvPlugin* plugin,
                                       const LilvNode*   class_1,
                                       va_list           args)
@@ -628,7 +628,7 @@ lilv_plugin_get_num_ports_of_class_va(const LilvPlugin* plugin,
 	return count;
 }
 
-LILV_API uint32_t
+uint32_t
 lilv_plugin_get_num_ports_of_class(const LilvPlugin* plugin,
                                    const LilvNode*   class_1, ...)
 {
@@ -641,7 +641,7 @@ lilv_plugin_get_num_ports_of_class(const LilvPlugin* plugin,
 	return count;
 }
 
-LILV_API bool
+bool
 lilv_plugin_has_latency(const LilvPlugin* plugin)
 {
 	lilv_plugin_load_if_necessary(plugin);
@@ -701,7 +701,7 @@ lilv_plugin_get_port_by_property(const LilvPlugin* plugin,
 	return NULL;
 }
 
-LILV_API const LilvPort*
+const LilvPort*
 lilv_plugin_get_port_by_designation(const LilvPlugin* plugin,
                                     const LilvNode*   port_class,
                                     const LilvNode*   designation)
@@ -728,7 +728,7 @@ lilv_plugin_get_port_by_designation(const LilvPlugin* plugin,
 	return NULL;
 }
 
-LILV_API uint32_t
+uint32_t
 lilv_plugin_get_latency_port_index(const LilvPlugin* plugin)
 {
 	LilvNode* lv2_OutputPort =
@@ -753,7 +753,7 @@ lilv_plugin_get_latency_port_index(const LilvPlugin* plugin)
 	}
 }
 
-LILV_API bool
+bool
 lilv_plugin_has_feature(const LilvPlugin* plugin,
                         const LilvNode*   feature)
 {
@@ -771,7 +771,7 @@ lilv_plugin_has_feature(const LilvPlugin* plugin,
 	return false;
 }
 
-LILV_API LilvNodes*
+LilvNodes*
 lilv_plugin_get_supported_features(const LilvPlugin* plugin)
 {
 	LilvNodes* optional = lilv_plugin_get_optional_features(plugin);
@@ -782,7 +782,7 @@ lilv_plugin_get_supported_features(const LilvPlugin* plugin)
 	return result;
 }
 
-LILV_API LilvNodes*
+LilvNodes*
 lilv_plugin_get_optional_features(const LilvPlugin* plugin)
 {
 	lilv_plugin_load_if_necessary(plugin);
@@ -792,7 +792,7 @@ lilv_plugin_get_optional_features(const LilvPlugin* plugin)
 	                                      NULL);
 }
 
-LILV_API LilvNodes*
+LilvNodes*
 lilv_plugin_get_required_features(const LilvPlugin* plugin)
 {
 	lilv_plugin_load_if_necessary(plugin);
@@ -802,7 +802,7 @@ lilv_plugin_get_required_features(const LilvPlugin* plugin)
 	                                      NULL);
 }
 
-LILV_API bool
+bool
 lilv_plugin_has_extension_data(const LilvPlugin* plugin,
                                const LilvNode*   uri)
 {
@@ -820,13 +820,13 @@ lilv_plugin_has_extension_data(const LilvPlugin* plugin,
 		uri->node);
 }
 
-LILV_API LilvNodes*
+LilvNodes*
 lilv_plugin_get_extension_data(const LilvPlugin* plugin)
 {
 	return lilv_plugin_get_value_internal(plugin, plugin->world->uris.lv2_extensionData);
 }
 
-LILV_API const LilvPort*
+const LilvPort*
 lilv_plugin_get_port_by_index(const LilvPlugin* plugin,
                               uint32_t          index)
 {
@@ -838,7 +838,7 @@ lilv_plugin_get_port_by_index(const LilvPlugin* plugin,
 	}
 }
 
-LILV_API const LilvPort*
+const LilvPort*
 lilv_plugin_get_port_by_symbol(const LilvPlugin* plugin,
                                const LilvNode*   symbol)
 {
@@ -853,7 +853,7 @@ lilv_plugin_get_port_by_symbol(const LilvPlugin* plugin,
 	return NULL;
 }
 
-LILV_API LilvNode*
+LilvNode*
 lilv_plugin_get_project(const LilvPlugin* plugin)
 {
 	lilv_plugin_load_if_necessary(plugin);
@@ -938,31 +938,31 @@ lilv_plugin_get_author_property(const LilvPlugin* plugin, const uint8_t* uri)
 	return NULL;
 }
 
-LILV_API LilvNode*
+LilvNode*
 lilv_plugin_get_author_name(const LilvPlugin* plugin)
 {
 	return lilv_plugin_get_author_property(plugin, NS_FOAF "name");
 }
 
-LILV_API LilvNode*
+LilvNode*
 lilv_plugin_get_author_email(const LilvPlugin* plugin)
 {
 	return lilv_plugin_get_author_property(plugin, NS_FOAF "mbox");
 }
 
-LILV_API LilvNode*
+LilvNode*
 lilv_plugin_get_author_homepage(const LilvPlugin* plugin)
 {
 	return lilv_plugin_get_author_property(plugin, NS_FOAF "homepage");
 }
 
-LILV_API bool
+bool
 lilv_plugin_is_replaced(const LilvPlugin* plugin)
 {
 	return plugin->replaced;
 }
 
-LILV_API LilvUIs*
+LilvUIs*
 lilv_plugin_get_uis(const LilvPlugin* plugin)
 {
 	lilv_plugin_load_if_necessary(plugin);
@@ -1017,7 +1017,7 @@ lilv_plugin_get_uis(const LilvPlugin* plugin)
 	}
 }
 
-LILV_API LilvNodes*
+LilvNodes*
 lilv_plugin_get_related(const LilvPlugin* plugin, const LilvNode* type)
 {
 	lilv_plugin_load_if_necessary(plugin);
@@ -1077,7 +1077,7 @@ maybe_write_prefixes(SerdWriter* writer, SerdEnv* env, FILE* file)
 	}
 }
 
-LILV_API void
+void
 lilv_plugin_write_description(LilvWorld*        world,
                               const LilvPlugin* plugin,
                               const LilvNode*   base_uri,
@@ -1116,7 +1116,7 @@ lilv_plugin_write_description(LilvWorld*        world,
 	serd_env_free(env);
 }
 
-LILV_API void
+void
 lilv_plugin_write_manifest_entry(LilvWorld*        world,
                                  const LilvPlugin* plugin,
                                  const LilvNode*   base_uri,
diff --git a/src/pluginclass.c b/src/pluginclass.c
index 4248871..538722f 100644
--- a/src/pluginclass.c
+++ b/src/pluginclass.c
@@ -52,25 +52,25 @@ lilv_plugin_class_free(LilvPluginClass* plugin_class)
 	free(plugin_class);
 }
 
-LILV_API const LilvNode*
+const LilvNode*
 lilv_plugin_class_get_parent_uri(const LilvPluginClass* plugin_class)
 {
 	return plugin_class->parent_uri ? plugin_class->parent_uri : NULL;
 }
 
-LILV_API const LilvNode*
+const LilvNode*
 lilv_plugin_class_get_uri(const LilvPluginClass* plugin_class)
 {
 	return plugin_class->uri;
 }
 
-LILV_API const LilvNode*
+const LilvNode*
 lilv_plugin_class_get_label(const LilvPluginClass* plugin_class)
 {
 	return plugin_class->label;
 }
 
-LILV_API LilvPluginClasses*
+LilvPluginClasses*
 lilv_plugin_class_get_children(const LilvPluginClass* plugin_class)
 {
 	// Returned list doesn't own categories
diff --git a/src/port.c b/src/port.c
index bdcb176..be555fb 100644
--- a/src/port.c
+++ b/src/port.c
@@ -55,7 +55,7 @@ lilv_port_free(const LilvPlugin* plugin, LilvPort* port)
 	}
 }
 
-LILV_API bool
+bool
 lilv_port_is_a(const LilvPlugin* plugin,
                const LilvPort*   port,
                const LilvNode*   port_class)
@@ -69,7 +69,7 @@ lilv_port_is_a(const LilvPlugin* plugin,
 	return false;
 }
 
-LILV_API bool
+bool
 lilv_port_has_property(const LilvPlugin* plugin,
                        const LilvPort*   port,
                        const LilvNode*   property)
@@ -80,7 +80,7 @@ lilv_port_has_property(const LilvPlugin* plugin,
 	                               property->node);
 }
 
-LILV_API bool
+bool
 lilv_port_supports_event(const LilvPlugin* plugin,
                          const LilvPort*   port,
                          const LilvNode*   event_type)
@@ -111,14 +111,14 @@ lilv_port_get_value_by_node(const LilvPlugin* plugin,
 	                                      NULL);
 }
 
-LILV_API const LilvNode*
+const LilvNode*
 lilv_port_get_node(const LilvPlugin* plugin,
                    const LilvPort*   port)
 {
 	return port->node;
 }
 
-LILV_API LilvNodes*
+LilvNodes*
 lilv_port_get_value(const LilvPlugin* plugin,
                     const LilvPort*   port,
                     const LilvNode*   predicate)
@@ -132,7 +132,7 @@ lilv_port_get_value(const LilvPlugin* plugin,
 	return lilv_port_get_value_by_node(plugin, port, predicate->node);
 }
 
-LILV_API LilvNode*
+LilvNode*
 lilv_port_get(const LilvPlugin* plugin,
               const LilvPort*   port,
               const LilvNode*   predicate)
@@ -146,21 +146,21 @@ lilv_port_get(const LilvPlugin* plugin,
 	return value;
 }
 
-LILV_API uint32_t
+uint32_t
 lilv_port_get_index(const LilvPlugin* plugin,
                     const LilvPort*   port)
 {
 	return port->index;
 }
 
-LILV_API const LilvNode*
+const LilvNode*
 lilv_port_get_symbol(const LilvPlugin* plugin,
                      const LilvPort*   port)
 {
 	return port->symbol;
 }
 
-LILV_API LilvNode*
+LilvNode*
 lilv_port_get_name(const LilvPlugin* plugin,
                    const LilvPort*   port)
 {
@@ -184,14 +184,14 @@ lilv_port_get_name(const LilvPlugin* plugin,
 	return ret;
 }
 
-LILV_API const LilvNodes*
+const LilvNodes*
 lilv_port_get_classes(const LilvPlugin* plugin,
                       const LilvPort*   port)
 {
 	return port->classes;
 }
 
-LILV_API void
+void
 lilv_port_get_range(const LilvPlugin* plugin,
                     const LilvPort*   port,
                     LilvNode**        def,
@@ -224,7 +224,7 @@ lilv_port_get_range(const LilvPlugin* plugin,
 	}
 }
 
-LILV_API LilvScalePoints*
+LilvScalePoints*
 lilv_port_get_scale_points(const LilvPlugin* plugin,
                            const LilvPort*   port)
 {
@@ -261,7 +261,7 @@ lilv_port_get_scale_points(const LilvPlugin* plugin,
 	return ret;
 }
 
-LILV_API LilvNodes*
+LilvNodes*
 lilv_port_get_properties(const LilvPlugin* plugin,
                          const LilvPort*   port)
 {
diff --git a/src/scalepoint.c b/src/scalepoint.c
index 8791b88..31e33c2 100644
--- a/src/scalepoint.c
+++ b/src/scalepoint.c
@@ -40,13 +40,13 @@ lilv_scale_point_free(LilvScalePoint* point)
 	}
 }
 
-LILV_API const LilvNode*
+const LilvNode*
 lilv_scale_point_get_value(const LilvScalePoint* point)
 {
 	return point->value;
 }
 
-LILV_API const LilvNode*
+const LilvNode*
 lilv_scale_point_get_label(const LilvScalePoint* point)
 {
 	return point->label;
diff --git a/src/state.c b/src/state.c
index 23a659d..35dd502 100644
--- a/src/state.c
+++ b/src/state.c
@@ -386,7 +386,7 @@ lilv_free_path(LV2_State_Free_Path_Handle handle, char* path)
 	lilv_free(path);
 }
 
-LILV_API LilvState*
+LilvState*
 lilv_state_new_from_instance(const LilvPlugin*          plugin,
                              LilvInstance*              instance,
                              LV2_URID_Map*              map,
@@ -464,7 +464,7 @@ lilv_state_new_from_instance(const LilvPlugin*          plugin,
 	return state;
 }
 
-LILV_API void
+void
 lilv_state_emit_port_values(const LilvState*     state,
                             LilvSetPortValueFunc set_value,
                             void*                user_data)
@@ -476,7 +476,7 @@ lilv_state_emit_port_values(const LilvState*     state,
 	}
 }
 
-LILV_API void
+void
 lilv_state_restore(const LilvState*           state,
                    LilvInstance*              instance,
                    LilvSetPortValueFunc       set_value,
@@ -671,7 +671,7 @@ new_state_from_model(LilvWorld*       world,
 	return state;
 }
 
-LILV_API LilvState*
+LilvState*
 lilv_state_new_from_world(LilvWorld*      world,
                           LV2_URID_Map*   map,
                           const LilvNode* node)
@@ -685,7 +685,7 @@ lilv_state_new_from_world(LilvWorld*      world,
 	return new_state_from_model(world, map, world->model, node->node, NULL);
 }
 
-LILV_API LilvState*
+LilvState*
 lilv_state_new_from_file(LilvWorld*      world,
                          LV2_URID_Map*   map,
                          const LilvNode* subject,
@@ -738,7 +738,7 @@ set_prefixes(SerdEnv* env)
 	SET_PSET(env, USTR("xsd"),   USTR(LILV_NS_XSD));
 }
 
-LILV_API LilvState*
+LilvState*
 lilv_state_new_from_string(LilvWorld*    world,
                            LV2_URID_Map* map,
                            const char*   str)
@@ -1116,7 +1116,7 @@ lilv_state_make_links(const LilvState* state, const char* dir)
 	}
 }
 
-LILV_API int
+int
 lilv_state_save(LilvWorld*       world,
                 LV2_URID_Map*    map,
                 LV2_URID_Unmap*  unmap,
@@ -1171,7 +1171,7 @@ lilv_state_save(LilvWorld*       world,
 	return ret;
 }
 
-LILV_API char*
+char*
 lilv_state_to_string(LilvWorld*       world,
                      LV2_URID_Map*    map,
                      LV2_URID_Unmap*  unmap,
@@ -1207,7 +1207,7 @@ try_unlink(const char* path)
 	}
 }
 
-LILV_API int
+int
 lilv_state_delete(LilvWorld*       world,
                   const LilvState* state)
 {
@@ -1293,7 +1293,7 @@ free_property_array(LilvState* state, PropertyArray* array)
 	free(array->props);
 }
 
-LILV_API void
+void
 lilv_state_free(LilvState* state)
 {
 	if (state) {
@@ -1317,7 +1317,7 @@ lilv_state_free(LilvState* state)
 	}
 }
 
-LILV_API bool
+bool
 lilv_state_equals(const LilvState* a, const LilvState* b)
 {
 	if (!lilv_node_equals(a->plugin_uri, b->plugin_uri)
@@ -1361,31 +1361,31 @@ lilv_state_equals(const LilvState* a, const LilvState* b)
 	return true;
 }
 
-LILV_API unsigned
+unsigned
 lilv_state_get_num_properties(const LilvState* state)
 {
 	return state->props.n;
 }
 
-LILV_API const LilvNode*
+const LilvNode*
 lilv_state_get_plugin_uri(const LilvState* state)
 {
 	return state->plugin_uri;
 }
 
-LILV_API const LilvNode*
+const LilvNode*
 lilv_state_get_uri(const LilvState* state)
 {
 	return state->uri;
 }
 
-LILV_API const char*
+const char*
 lilv_state_get_label(const LilvState* state)
 {
 	return state->label;
 }
 
-LILV_API void
+void
 lilv_state_set_label(LilvState* state, const char* label)
 {
 	const size_t len = strlen(label);
@@ -1393,7 +1393,7 @@ lilv_state_set_label(LilvState* state, const char* label)
 	memcpy(state->label, label, len + 1);
 }
 
-LILV_API int
+int
 lilv_state_set_metadata(LilvState*  state,
                         uint32_t    key,
                         const void* value,
diff --git a/src/ui.c b/src/ui.c
index acc9150..cfe788e 100644
--- a/src/ui.c
+++ b/src/ui.c
@@ -62,13 +62,13 @@ lilv_ui_free(LilvUI* ui)
 	free(ui);
 }
 
-LILV_API const LilvNode*
+const LilvNode*
 lilv_ui_get_uri(const LilvUI* ui)
 {
 	return ui->uri;
 }
 
-LILV_API unsigned
+unsigned
 lilv_ui_is_supported(const LilvUI*       ui,
                      LilvUISupportedFunc supported_func,
                      const LilvNode*     container_type,
@@ -90,25 +90,25 @@ lilv_ui_is_supported(const LilvUI*       ui,
 	return 0;
 }
 
-LILV_API const LilvNodes*
+const LilvNodes*
 lilv_ui_get_classes(const LilvUI* ui)
 {
 	return ui->classes;
 }
 
-LILV_API bool
+bool
 lilv_ui_is_a(const LilvUI* ui, const LilvNode* class_uri)
 {
 	return lilv_nodes_contains(ui->classes, class_uri);
 }
 
-LILV_API const LilvNode*
+const LilvNode*
 lilv_ui_get_bundle_uri(const LilvUI* ui)
 {
 	return ui->bundle_uri;
 }
 
-LILV_API const LilvNode*
+const LilvNode*
 lilv_ui_get_binary_uri(const LilvUI* ui)
 {
 	return ui->binary_uri;
diff --git a/src/world.c b/src/world.c
index 0bf7cf3..970111c 100644
--- a/src/world.c
+++ b/src/world.c
@@ -41,7 +41,7 @@
 static int
 lilv_world_drop_graph(LilvWorld* world, const SordNode* graph);
 
-LILV_API LilvWorld*
+LilvWorld*
 lilv_world_new(void)
 {
 	LilvWorld* world = (LilvWorld*)calloc(1, sizeof(LilvWorld));
@@ -125,7 +125,7 @@ fail:
 	return NULL;
 }
 
-LILV_API void
+void
 lilv_world_free(LilvWorld* world)
 {
 	if (!world) {
@@ -182,7 +182,7 @@ lilv_world_free(LilvWorld* world)
 	free(world);
 }
 
-LILV_API void
+void
 lilv_world_set_option(LilvWorld*      world,
                       const char*     uri,
                       const LilvNode* value)
@@ -206,7 +206,7 @@ lilv_world_set_option(LilvWorld*      world,
 	LILV_WARNF("Unrecognized or invalid option `%s'\n", uri);
 }
 
-LILV_API LilvNodes*
+LilvNodes*
 lilv_world_find_nodes(LilvWorld*      world,
                       const LilvNode* subject,
                       const LilvNode* predicate,
@@ -234,7 +234,7 @@ lilv_world_find_nodes(LilvWorld*      world,
 	                                      object ? object->node : NULL);
 }
 
-LILV_API LilvNode*
+LilvNode*
 lilv_world_get(LilvWorld*      world,
                const LilvNode* subject,
                const LilvNode* predicate,
@@ -268,7 +268,7 @@ lilv_world_ask_internal(LilvWorld*      world,
 	return sord_ask(world->model, subject, predicate, object, NULL);
 }
 
-LILV_API bool
+bool
 lilv_world_ask(LilvWorld*      world,
                const LilvNode* subject,
                const LilvNode* predicate,
@@ -700,7 +700,7 @@ get_version(LilvWorld* world, SordModel* model, const LilvNode* subject)
 	return version;
 }
 
-LILV_API void
+void
 lilv_world_load_bundle(LilvWorld* world, const LilvNode* bundle_uri)
 {
 	if (!lilv_node_is_uri(bundle_uri)) {
@@ -863,7 +863,7 @@ lilv_world_unload_file(LilvWorld* world, const LilvNode* file)
 	return 1;
 }
 
-LILV_API int
+int
 lilv_world_unload_bundle(LilvWorld* world, const LilvNode* bundle_uri)
 {
 	if (!bundle_uri) {
@@ -1034,7 +1034,7 @@ lilv_world_load_plugin_classes(LilvWorld* world)
 	sord_iter_free(classes);
 }
 
-LILV_API void
+void
 lilv_world_load_all(LilvWorld* world)
 {
 	const char* lv2_path = world->opt.lv2_path;
@@ -1098,7 +1098,7 @@ lilv_world_load_file(LilvWorld* world, SerdReader* reader, const LilvNode* uri)
 	return SERD_SUCCESS;
 }
 
-LILV_API int
+int
 lilv_world_load_resource(LilvWorld*      world,
                          const LilvNode* resource)
 {
@@ -1133,7 +1133,7 @@ lilv_world_load_resource(LilvWorld*      world,
 	return n_read;
 }
 
-LILV_API int
+int
 lilv_world_unload_resource(LilvWorld*      world,
                            const LilvNode* resource)
 {
@@ -1169,25 +1169,25 @@ lilv_world_unload_resource(LilvWorld*      world,
 	return n_dropped;
 }
 
-LILV_API const LilvPluginClass*
+const LilvPluginClass*
 lilv_world_get_plugin_class(const LilvWorld* world)
 {
 	return world->lv2_plugin_class;
 }
 
-LILV_API const LilvPluginClasses*
+const LilvPluginClasses*
 lilv_world_get_plugin_classes(const LilvWorld* world)
 {
 	return world->plugin_classes;
 }
 
-LILV_API const LilvPlugins*
+const LilvPlugins*
 lilv_world_get_all_plugins(const LilvWorld* world)
 {
 	return world->plugins;
 }
 
-LILV_API LilvNode*
+LilvNode*
 lilv_world_get_symbol(LilvWorld* world, const LilvNode* subject)
 {
 	// Check for explicitly given symbol