Fix inconsistent parameter names

1 files changed, 34 insertions, 34 deletions

diff --git a/src/port.c b/src/port.c
index 3ddc9b7..fcc32fc 100644
--- a/src/port.c
+++ b/src/port.c
@@ -65,30 +65,30 @@ lilv_port_is_a(const LilvPlugin* plugin,
 }
 
 LILV_API bool
-lilv_port_has_property(const LilvPlugin* p,
+lilv_port_has_property(const LilvPlugin* plugin,
                        const LilvPort*   port,
                        const LilvNode*   property)
 {
-	return lilv_world_ask_internal(p->world,
+	return lilv_world_ask_internal(plugin->world,
 	                               port->node->node,
-	                               p->world->uris.lv2_portProperty,
+	                               plugin->world->uris.lv2_portProperty,
 	                               property->node);
 }
 
 LILV_API bool
-lilv_port_supports_event(const LilvPlugin* p,
+lilv_port_supports_event(const LilvPlugin* plugin,
                          const LilvPort*   port,
-                         const LilvNode*   event)
+                         const LilvNode*   event_type)
 {
 	const uint8_t* predicates[] = { (const uint8_t*)LV2_EVENT__supportsEvent,
 	                                (const uint8_t*)LV2_ATOM__supports,
 	                                NULL };
 
 	for (const uint8_t** pred = predicates; *pred; ++pred) {
-		if (lilv_world_ask_internal(p->world,
+		if (lilv_world_ask_internal(plugin->world,
 		                            port->node->node,
-		                            sord_new_uri(p->world->world, *pred),
-		                            event->node)) {
+		                            sord_new_uri(plugin->world->world, *pred),
+		                            event_type->node)) {
 			return true;
 		}
 	}
@@ -96,11 +96,11 @@ lilv_port_supports_event(const LilvPlugin* p,
 }
 
 static LilvNodes*
-lilv_port_get_value_by_node(const LilvPlugin* p,
+lilv_port_get_value_by_node(const LilvPlugin* plugin,
                             const LilvPort*   port,
                             const SordNode*   predicate)
 {
-	return lilv_world_find_nodes_internal(p->world,
+	return lilv_world_find_nodes_internal(plugin->world,
 	                                      port->node->node,
 	                                      predicate,
 	                                      NULL);
@@ -114,7 +114,7 @@ lilv_port_get_node(const LilvPlugin* plugin,
 }
 
 LILV_API LilvNodes*
-lilv_port_get_value(const LilvPlugin* p,
+lilv_port_get_value(const LilvPlugin* plugin,
                     const LilvPort*   port,
                     const LilvNode*   predicate)
 {
@@ -124,15 +124,15 @@ lilv_port_get_value(const LilvPlugin* p,
 		return NULL;
 	}
 
-	return lilv_port_get_value_by_node(p, port, predicate->node);
+	return lilv_port_get_value_by_node(plugin, port, predicate->node);
 }
 
 LILV_API LilvNode*
-lilv_port_get(const LilvPlugin* p,
+lilv_port_get(const LilvPlugin* plugin,
               const LilvPort*   port,
               const LilvNode*   predicate)
 {
-	LilvNodes* values = lilv_port_get_value(p, port, predicate);
+	LilvNodes* values = lilv_port_get_value(plugin, port, predicate);
 
 	LilvNode* value = lilv_node_duplicate(
 		values ? lilv_nodes_get_first(values) : NULL);
@@ -142,25 +142,25 @@ lilv_port_get(const LilvPlugin* p,
 }
 
 LILV_API uint32_t
-lilv_port_get_index(const LilvPlugin* p,
+lilv_port_get_index(const LilvPlugin* plugin,
                     const LilvPort*   port)
 {
 	return port->index;
 }
 
 LILV_API const LilvNode*
-lilv_port_get_symbol(const LilvPlugin* p,
+lilv_port_get_symbol(const LilvPlugin* plugin,
                      const LilvPort*   port)
 {
 	return port->symbol;
 }
 
 LILV_API LilvNode*
-lilv_port_get_name(const LilvPlugin* p,
+lilv_port_get_name(const LilvPlugin* plugin,
                    const LilvPort*   port)
 {
 	LilvNodes* results = lilv_port_get_value_by_node(
-		p, port, p->world->uris.lv2_name);
+		plugin, port, plugin->world->uris.lv2_name);
 
 	LilvNode* ret = NULL;
 	if (results) {
@@ -173,21 +173,21 @@ lilv_port_get_name(const LilvPlugin* p,
 
 	if (!ret) {
 		LILV_WARNF("Plugin <%s> port has no (mandatory) doap:name\n",
-		           lilv_node_as_string(lilv_plugin_get_uri(p)));
+		           lilv_node_as_string(lilv_plugin_get_uri(plugin)));
 	}
 
 	return ret;
 }
 
 LILV_API const LilvNodes*
-lilv_port_get_classes(const LilvPlugin* p,
+lilv_port_get_classes(const LilvPlugin* plugin,
                       const LilvPort*   port)
 {
 	return port->classes;
 }
 
 LILV_API void
-lilv_port_get_range(const LilvPlugin* p,
+lilv_port_get_range(const LilvPlugin* plugin,
                     const LilvPort*   port,
                     LilvNode**        def,
                     LilvNode**        min,
@@ -195,7 +195,7 @@ lilv_port_get_range(const LilvPlugin* p,
 {
 	if (def) {
 		LilvNodes* defaults = lilv_port_get_value_by_node(
-			p, port, p->world->uris.lv2_default);
+			plugin, port, plugin->world->uris.lv2_default);
 		*def = defaults
 			? lilv_node_duplicate(lilv_nodes_get_first(defaults))
 			: NULL;
@@ -203,7 +203,7 @@ lilv_port_get_range(const LilvPlugin* p,
 	}
 	if (min) {
 		LilvNodes* minimums = lilv_port_get_value_by_node(
-			p, port, p->world->uris.lv2_minimum);
+			plugin, port, plugin->world->uris.lv2_minimum);
 		*min = minimums
 			? lilv_node_duplicate(lilv_nodes_get_first(minimums))
 			: NULL;
@@ -211,7 +211,7 @@ lilv_port_get_range(const LilvPlugin* p,
 	}
 	if (max) {
 		LilvNodes* maximums = lilv_port_get_value_by_node(
-			p, port, p->world->uris.lv2_maximum);
+			plugin, port, plugin->world->uris.lv2_maximum);
 		*max = maximums
 			? lilv_node_duplicate(lilv_nodes_get_first(maximums))
 			: NULL;
@@ -220,13 +220,13 @@ lilv_port_get_range(const LilvPlugin* p,
 }
 
 LILV_API LilvScalePoints*
-lilv_port_get_scale_points(const LilvPlugin* p,
+lilv_port_get_scale_points(const LilvPlugin* plugin,
                            const LilvPort*   port)
 {
 	SordIter* points = lilv_world_query_internal(
-		p->world,
+		plugin->world,
 		port->node->node,
-		sord_new_uri(p->world->world, (const uint8_t*)LV2_CORE__scalePoint),
+		sord_new_uri(plugin->world->world, (const uint8_t*)LV2_CORE__scalePoint),
 		NULL);
 
 	LilvScalePoints* ret = NULL;
@@ -237,13 +237,13 @@ lilv_port_get_scale_points(const LilvPlugin* p,
 	FOREACH_MATCH(points) {
 		const SordNode* point = sord_iter_get_node(points, SORD_OBJECT);
 
-		LilvNode* value = lilv_plugin_get_unique(p,
+		LilvNode* value = lilv_plugin_get_unique(plugin,
 		                                         point,
-		                                         p->world->uris.rdf_value);
+		                                         plugin->world->uris.rdf_value);
 
-		LilvNode* label = lilv_plugin_get_unique(p,
+		LilvNode* label = lilv_plugin_get_unique(plugin,
 		                                         point,
-		                                         p->world->uris.rdfs_label);
+		                                         plugin->world->uris.rdfs_label);
 
 		if (value && label) {
 			zix_tree_insert(
@@ -257,12 +257,12 @@ lilv_port_get_scale_points(const LilvPlugin* p,
 }
 
 LILV_API LilvNodes*
-lilv_port_get_properties(const LilvPlugin* p,
+lilv_port_get_properties(const LilvPlugin* plugin,
                          const LilvPort*   port)
 {
 	LilvNode* pred = lilv_node_new_from_node(
-		p->world, p->world->uris.lv2_portProperty);
-	LilvNodes* ret = lilv_port_get_value(p, port, pred);
+		plugin->world, plugin->world->uris.lv2_portProperty);
+	LilvNodes* ret = lilv_port_get_value(plugin, port, pred);
 	lilv_node_free(pred);
 	return ret;
 }