summaryrefslogtreecommitdiffstats
path: root/src/state.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/state.c')
-rw-r--r--src/state.c482
1 files changed, 345 insertions, 137 deletions
diff --git a/src/state.c b/src/state.c
index 05570cd..512cccf 100644
--- a/src/state.c
+++ b/src/state.c
@@ -14,8 +14,7 @@
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
-#define _POSIX_SOURCE 1 /* for fileno */
-#define _BSD_SOURCE 1 /* for lockf */
+#define _BSD_SOURCE 1 /* for realpath, symlink */
#include <errno.h>
#include <stdio.h>
@@ -28,15 +27,13 @@
# include "lv2/lv2plug.in/ns/ext/state/state.h"
#endif
-#if defined(HAVE_LOCKF) && defined(HAVE_FILENO)
-# include <unistd.h>
-#endif
-
#ifdef HAVE_MKDIR
# include <sys/stat.h>
# include <sys/types.h>
#endif
+#include <unistd.h>
+
#define NS_ATOM "http://lv2plug.in/ns/ext/atom#"
#define NS_PSET "http://lv2plug.in/ns/ext/presets#"
#define NS_STATE "http://lv2plug.in/ns/ext/state#"
@@ -56,16 +53,48 @@ typedef struct {
LilvNode* value;
} PortValue;
+typedef struct {
+ char* abs; ///< Absolute path of actual file
+ char* rel; ///< Abstract path (relative path in state dir)
+} PathMap;
+
struct LilvStateImpl {
LilvNode* plugin_uri;
+ char* dir; ///< Save directory (if saved)
+ char* file_dir; ///< Directory of files created by plugin
+ char* label;
+ ZixTree* abs2rel; ///< PathMap sorted by abs
+ ZixTree* rel2abs; ///< PathMap sorted by rel
Property* props;
PortValue* values;
- char* label;
+ uint32_t state_Path;
uint32_t num_props;
uint32_t num_values;
};
static int
+abs_cmp(const void* a, const void* b, void* user_data)
+{
+ return strcmp(((const PathMap*)a)->abs,
+ ((const PathMap*)b)->abs);
+}
+
+static int
+rel_cmp(const void* a, const void* b, void* user_data)
+{
+ return strcmp(((const PathMap*)a)->rel,
+ ((const PathMap*)b)->rel);
+}
+
+static void
+path_rel_free(void* ptr)
+{
+ free(((PathMap*)ptr)->abs);
+ free(((PathMap*)ptr)->rel);
+ free(ptr);
+}
+
+static int
property_cmp(const void* a, const void* b)
{
const Property* pa = (const Property*)a;
@@ -95,6 +124,7 @@ append_port_value(LilvState* state,
}
#ifdef HAVE_LV2_STATE
+
static int
store_callback(void* handle,
uint32_t key,
@@ -103,19 +133,18 @@ store_callback(void* handle,
uint32_t type,
uint32_t flags)
{
- if (!(flags & LV2_STATE_IS_POD)) {
- // TODO: A flag so we know if we can hold a reference would be nice
- LILV_WARN("Non-POD property ignored.\n");
- return 1;
- }
-
LilvState* const state = (LilvState*)handle;
state->props = realloc(state->props,
(++state->num_props) * sizeof(Property));
Property* const prop = &state->props[state->num_props - 1];
- prop->value = malloc(size);
- memcpy(prop->value, value, size);
+ if ((flags & LV2_STATE_IS_POD) || type == state->state_Path) {
+ prop->value = malloc(size);
+ memcpy(prop->value, value, size);
+ } else {
+ LILV_WARN("Storing non-POD value\n");
+ prop->value = (void*)value;
+ }
prop->size = size;
prop->key = key;
@@ -124,21 +153,157 @@ store_callback(void* handle,
return 0;
}
+
+static const void*
+retrieve_callback(void* handle,
+ uint32_t key,
+ size_t* size,
+ uint32_t* type,
+ uint32_t* flags)
+{
+ const LilvState* const state = (LilvState*)handle;
+ const Property search_key = { NULL, 0, key, 0, 0 };
+ const Property* const prop = (Property*)bsearch(
+ &search_key, state->props, state->num_props,
+ sizeof(Property), property_cmp);
+
+ if (prop) {
+ *size = prop->size;
+ *type = prop->type;
+ *flags = prop->flags;
+ return prop->value;
+ }
+ return NULL;
+}
+
+static const char*
+lilv_state_rel2abs(const LilvState* state, const char* path)
+{
+ ZixTreeIter* iter = NULL;
+ const PathMap key = { NULL, (char*)path };
+ if (state->rel2abs && !zix_tree_find(state->rel2abs, &key, &iter)) {
+ return ((const PathMap*)zix_tree_get(iter))->abs;
+ }
+ return path;
+}
+
+static bool
+lilv_state_has_path(const char* path, void* state)
+{
+ return lilv_state_rel2abs((LilvState*)state, path) != path;
+}
+
+static char*
+abstract_path(LV2_State_Map_Path_Handle handle,
+ const char* absolute_path)
+{
+ LilvState* state = (LilvState*)handle;
+ const size_t file_dir_len = state->file_dir ? strlen(state->file_dir) : 0;
+ char* path = NULL;
+ char* real_path = realpath(absolute_path, NULL);
+ const PathMap key = { (char*)real_path, NULL };
+ ZixTreeIter* iter = NULL;
+
+ if (!zix_tree_find(state->abs2rel, &key, &iter)) {
+ // Already mapped path in a previous call
+ PathMap* pm = (PathMap*)zix_tree_get(iter);
+ free(real_path);
+ return lilv_strdup(pm->rel);
+ } else if (lilv_path_is_child(real_path, state->file_dir)) {
+ // File created by plugin
+ char* copy = lilv_get_latest_copy(real_path);
+ if (!copy) {
+ // No recent enough copy, make a new one
+ copy = lilv_find_free_path(real_path, lilv_path_exists, NULL);
+ lilv_copy_file(real_path, copy);
+ }
+ real_path = copy;
+
+ // Refer to the latest copy in plugin state
+ path = lilv_strdup(copy + file_dir_len + 1);
+ } else {
+ // New path outside state directory
+ const char* slash = strrchr(real_path, '/');
+ const char* name = slash ? (slash + 1) : real_path;
+
+ // Find a free name in the (virtual) state directory
+ path = lilv_find_free_path(name, lilv_state_has_path, state);
+ }
+
+ // Add record to path mapping
+ PathMap* pm = malloc(sizeof(PathMap));
+ pm->abs = real_path;
+ pm->rel = lilv_strdup(path);
+ zix_tree_insert(state->abs2rel, pm, NULL);
+ zix_tree_insert(state->rel2abs, pm, NULL);
+
+ return path;
+}
+
+static char*
+absolute_path(LV2_State_Map_Path_Handle handle,
+ const char* abstract_path)
+{
+ LilvState* state = (LilvState*)handle;
+ char* path = NULL;
+ if (lilv_path_is_absolute(abstract_path)) {
+ // Absolute path, return identical path
+ path = lilv_strdup(abstract_path);
+ } else {
+ // Relative path inside state directory
+ path = lilv_strjoin(state->dir, "/", abstract_path, NULL);
+ }
+
+ return path;
+}
+
#endif // HAVE_LV2_STATE
+/** Return a new features array which is @c feature added to @c features. */
+const LV2_Feature**
+add_feature(const LV2_Feature *const * features, const LV2_Feature* feature)
+{
+ size_t n_features = 0;
+ for (; features && features[n_features]; ++n_features) {}
+
+ const LV2_Feature** ret = malloc((n_features + 2) * sizeof(LV2_Feature*));
+
+ ret[0] = feature;
+ if (features) {
+ memcpy(ret + 1, features, n_features * sizeof(LV2_Feature*));
+ }
+ ret[n_features + 1] = NULL;
+ return ret;
+}
+
LILV_API
LilvState*
lilv_state_new_from_instance(const LilvPlugin* plugin,
LilvInstance* instance,
+ LV2_URID_Map* map,
+ const char* dir,
LilvGetPortValueFunc get_value,
void* user_data,
uint32_t flags,
const LV2_Feature *const * features)
{
- LilvWorld* const world = plugin->world;
- LilvState* const state = malloc(sizeof(LilvState));
+ const LV2_Feature** local_features = NULL;
+ LilvWorld* const world = plugin->world;
+ LilvState* const state = malloc(sizeof(LilvState));
memset(state, '\0', sizeof(LilvState));
state->plugin_uri = lilv_node_duplicate(lilv_plugin_get_uri(plugin));
+ state->abs2rel = zix_tree_new(false, abs_cmp, NULL, path_rel_free);
+ state->rel2abs = zix_tree_new(false, rel_cmp, NULL, NULL);
+ state->file_dir = dir ? realpath(dir, NULL) : NULL;
+ state->state_Path = map->map(map->handle, LV2_STATE_PATH_URI);
+
+#ifdef HAVE_LV2_STATE
+ if (dir) {
+ LV2_State_Map_Path map_path = { state, abstract_path, absolute_path };
+ LV2_Feature feature = { LV2_STATE_MAP_PATH_URI, &map_path };
+ features = local_features = add_feature(features, &feature);
+ }
+#endif
// Store port values
LilvNode* lv2_ControlPort = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
@@ -161,39 +326,18 @@ lilv_state_new_from_instance(const LilvPlugin* plugin,
? descriptor->extension_data(LV2_STATE_INTERFACE_URI)
: NULL;
- iface->save(instance->lv2_handle, store_callback, state, flags, features);
+ if (iface) {
+ iface->save(instance->lv2_handle, store_callback, state, flags, features);
+ }
#endif // HAVE_LV2_STATE
qsort(state->props, state->num_props, sizeof(Property), property_cmp);
qsort(state->values, state->num_values, sizeof(PortValue), value_cmp);
+ free(local_features);
return state;
}
-#ifdef HAVE_LV2_STATE
-static const void*
-retrieve_callback(void* handle,
- uint32_t key,
- size_t* size,
- uint32_t* type,
- uint32_t* flags)
-{
- const LilvState* const state = (LilvState*)handle;
- const Property search_key = { NULL, 0, key, 0, 0 };
- const Property* const prop = (Property*)bsearch(
- &search_key, state->props, state->num_props,
- sizeof(Property), property_cmp);
-
- if (prop) {
- *size = prop->size;
- *type = prop->type;
- *flags = prop->flags;
- return prop->value;
- }
- return NULL;
-}
-#endif // HAVE_LV2_STATE
-
LILV_API
void
lilv_state_restore(const LilvState* state,
@@ -204,13 +348,25 @@ lilv_state_restore(const LilvState* state,
const LV2_Feature *const * features)
{
#ifdef HAVE_LV2_STATE
+ LV2_State_Map_Path map_path = { (LilvState*)state, abstract_path, absolute_path };
+ LV2_Feature feature = { LV2_STATE_MAP_PATH_URI, &map_path };
+
+ const LV2_Feature** local_features = add_feature(features, &feature);
+ features = local_features;
+
const LV2_Descriptor* descriptor = instance->lv2_descriptor;
const LV2_State_Interface* iface = (descriptor->extension_data)
? descriptor->extension_data(LV2_STATE_INTERFACE_URI)
: NULL;
- iface->restore(instance->lv2_handle, retrieve_callback,
- (LV2_State_Handle)state, flags, features);
+ if (iface) {
+ iface->restore(instance->lv2_handle, retrieve_callback,
+ (LV2_State_Handle)state, flags, features);
+ }
+
+ free(local_features);
+
+#endif // HAVE_LV2_STATE
if (set_value) {
for (uint32_t i = 0; i < state->num_values; ++i) {
@@ -219,7 +375,6 @@ lilv_state_restore(const LilvState* state,
user_data);
}
}
-#endif // HAVE_LV2_STATE
}
static SordNode*
@@ -278,21 +433,28 @@ property_from_node(LilvWorld* world,
}
static LilvState*
-new_state_from_model(LilvWorld* world,
- LV2_URID_Map* map,
- SordModel* model,
- const SordNode* node)
+new_state_from_model(LilvWorld* world,
+ LV2_URID_Map* map,
+ SordModel* model,
+ const SordNode* node,
+ const char* dir)
{
LilvState* const state = malloc(sizeof(LilvState));
memset(state, '\0', sizeof(LilvState));
+ state->state_Path = map->map(map->handle, LV2_STATE_PATH_URI);
+ state->dir = dir ? lilv_strdup(dir) : NULL;
// Get the plugin URI this state applies to
const SordQuad upat = {
- node, world->lv2_appliesTo_node, NULL, NULL };
+ node, world->uris.lv2_appliesTo, NULL, NULL };
SordIter* i = sord_find(model, upat);
if (i) {
state->plugin_uri = lilv_node_new_from_node(
world, lilv_match_object(i));
+ if (!state->dir) {
+ state->dir = lilv_strdup(
+ (const char*)sord_node_get_string(lilv_match_graph(i)));
+ }
sord_iter_free(i);
} else {
LILV_ERRORF("State %s missing lv2:appliesTo property\n",
@@ -301,23 +463,26 @@ new_state_from_model(LilvWorld* world,
// Get the state label
const SordQuad lpat = {
- node, world->rdfs_label_node, NULL, NULL };
+ node, world->uris.rdfs_label, NULL, NULL };
i = sord_find(model, lpat);
if (i) {
state->label = lilv_strdup(
(const char*)sord_node_get_string(lilv_match_object(i)));
+ if (!state->dir) {
+ state->dir = lilv_strdup(
+ (const char*)sord_node_get_string(lilv_match_graph(i)));
+ }
sord_iter_free(i);
- } else {
}
// Get port values
- const SordQuad ppat = { node, world->lv2_port_node, NULL, NULL };
+ const SordQuad ppat = { node, world->uris.lv2_port, NULL, NULL };
SordIter* ports = sord_find(model, ppat);
FOREACH_MATCH(ports) {
const SordNode* port = lilv_match_object(ports);
- const SordNode* label = get_one(model, port, world->rdfs_label_node);
- const SordNode* symbol = get_one(model, port, world->lv2_symbol_node);
- const SordNode* value = get_one(model, port, world->pset_value_node);
+ const SordNode* label = get_one(model, port, world->uris.rdfs_label);
+ const SordNode* symbol = get_one(model, port, world->uris.lv2_symbol);
+ const SordNode* value = get_one(model, port, world->uris.pset_value);
if (!symbol) {
LILV_ERRORF("State `%s' port missing symbol.\n",
sord_node_get_string(node));
@@ -338,10 +503,12 @@ new_state_from_model(LilvWorld* world,
}
sord_iter_free(ports);
+ SordNode* state_path_node = sord_new_uri(world->world,
+ USTR(LV2_STATE_PATH_URI));
// Get properties
SordNode* statep = sord_new_uri(world->world, USTR(NS_STATE "state"));
const SordNode* state_node = get_one(model, node, statep);
- if (state_node) {
+ if (state) {
const SordQuad spat = { state_node, NULL, NULL };
SordIter* props = sord_find(model, spat);
FOREACH_MATCH(props) {
@@ -357,8 +524,8 @@ new_state_from_model(LilvWorld* world,
(const char*)sord_node_get_string(p));
if (sord_node_get_type(o) == SORD_BLANK) {
- const SordNode* type = get_one(model, o, world->rdf_a_node);
- const SordNode* value = get_one(model, o, world->rdf_value_node);
+ const SordNode* type = get_one(model, o, world->uris.rdf_a);
+ const SordNode* value = get_one(model, o, world->uris.rdf_value);
if (type && value) {
size_t len;
const uint8_t* b64 = sord_node_get_string_counted(value, &len);
@@ -369,6 +536,15 @@ new_state_from_model(LilvWorld* world,
LILV_ERRORF("Unable to parse blank node property <%p>\n",
sord_node_get_string(p));
}
+#ifdef HAVE_LV2_STATE
+ } else if (sord_node_equals(sord_node_get_datatype(o),
+ state_path_node)) {
+ prop.size = strlen((const char*)sord_node_get_string(o)) + 1;
+ prop.type = map->map(map->handle, LV2_STATE_PATH_URI);
+ prop.flags = LV2_STATE_IS_PORTABLE;
+ prop.value = lilv_strjoin(
+ state->dir, "/", sord_node_get_string(o), NULL);
+#endif
} else {
LilvNode* onode = lilv_node_new_from_node(world, o);
property_from_node(world, map, onode, &prop);
@@ -385,6 +561,7 @@ new_state_from_model(LilvWorld* world,
sord_iter_free(props);
}
sord_node_free(world->world, statep);
+ sord_node_free(world->world, state_path_node);
qsort(state->props, state->num_props, sizeof(Property), property_cmp);
qsort(state->values, state->num_values, sizeof(PortValue), value_cmp);
@@ -404,7 +581,10 @@ lilv_state_new_from_world(LilvWorld* world,
return NULL;
}
- return new_state_from_model(world, map, world->model, node->val.uri_val);
+ LilvState* state = new_state_from_model(
+ world, map, world->model, node->val.uri_val, NULL);
+
+ return state;
}
LILV_API
@@ -433,7 +613,12 @@ lilv_state_new_from_file(LilvWorld* world,
? subject->val.uri_val
: sord_node_from_serd_node(world->world, env, &base, NULL, NULL);
- LilvState* state = new_state_from_model(world, map, model, subject_node);
+ char* dirname = lilv_dirname(path);
+ char* real_path = realpath(dirname, NULL);
+ LilvState* state = new_state_from_model(
+ world, map, model, subject_node, real_path);
+ free(dirname);
+ free(real_path);
serd_reader_free(reader);
sord_free(model);
@@ -533,9 +718,7 @@ add_state_to_manifest(const LilvNode* plugin_uri,
serd_env_set_prefix_from_strings(env, USTR("rdf"), USTR(LILV_NS_RDF));
serd_env_set_prefix_from_strings(env, USTR("rdfs"), USTR(LILV_NS_RDFS));
-#if defined(HAVE_LOCKF) && defined(HAVE_FILENO)
- lockf(fileno(fd), F_LOCK, 0);
-#endif
+ lilv_flock(fd, true);
char* const manifest_uri = lilv_strjoin("file://", manifest_path, NULL);
@@ -581,9 +764,7 @@ add_state_to_manifest(const LilvNode* plugin_uri,
serd_writer_free(writer);
serd_node_free(&base);
-#ifdef HAVE_LOCKF
- lockf(fileno(fd), F_ULOCK, 0);
-#endif
+ lilv_flock(fd, false);
fclose(fd);
free(manifest_uri);
@@ -632,77 +813,63 @@ mkdir_p(const char* dir_path)
return 0;
}
-static int
-lilv_default_state_path(LilvWorld* world,
- const LilvState* state,
- char** path,
- char** manifest_path)
+static char*
+lilv_default_state_dir(LilvWorld* world)
{
#ifdef HAVE_MKDIR
- if (!state->label) {
- LILV_ERROR("Attempt to save state with no label or path.\n");
- return 1;
- }
-
+ // Use environment variable or default value if it is unset
char* state_bundle = getenv("LV2_STATE_BUNDLE");
if (!state_bundle) {
state_bundle = LILV_DEFAULT_STATE_BUNDLE;
}
- // Create ~/.lv2/presets.lv2/
- char* const bundle = lilv_expand(state_bundle);
- if (mkdir_p(bundle)) {
- free(bundle);
- return 3;
- }
-
- char* const filename = pathify(state->label);
-
- *path = lilv_strjoin(
- bundle, LILV_DIR_SEP, filename, ".ttl", NULL);
-
- *manifest_path = lilv_strjoin(
- bundle, LILV_DIR_SEP, "manifest.ttl", NULL);
-
- free(bundle);
- free(filename);
-
- return 0;
+ // Expand any variables and create if necessary
+ return lilv_expand(state_bundle);
#else
LILV_ERROR("Save to default state path but mkdir is unavailable.\n");
- return 4;
+ return NULL;
#endif
}
LILV_API
int
-lilv_state_save(LilvWorld* world,
- LV2_URID_Unmap* unmap,
- const LilvState* state,
- const char* uri,
- const char* path,
- const char* manifest_path)
-{
- char* default_path = NULL;
- char* default_manifest_path = NULL;
- if (!path) {
- if (lilv_default_state_path(
- world, state, &default_path, &default_manifest_path)) {
- return 1;
- }
-
- path = default_path;
- manifest_path = default_manifest_path;
+lilv_state_save(LilvWorld* world,
+ LV2_URID_Unmap* unmap,
+ const LilvState* state,
+ const char* uri,
+ const char* dir,
+ const char* filename,
+ const LV2_Feature *const * features)
+{
+ char* default_dir = NULL;
+ char* default_filename = NULL;
+ if (!dir) {
+ dir = default_dir = lilv_default_state_dir(world);
+ }
+ if (mkdir_p(dir)) {
+ free(default_dir);
+ return 1;
}
+ if (!filename) {
+ filename = default_filename = pathify(state->label);
+ }
+
+ char* const path = lilv_strjoin(dir, "/", filename, ".ttl", NULL);
FILE* fd = fopen(path, "w");
if (!fd) {
LILV_ERRORF("Failed to open %s (%s)\n", path, strerror(errno));
- free(default_path);
- free(default_manifest_path);
+ free(default_dir);
+ free(default_filename);
+ free(path);
return 4;
}
+ // FIXME: make parameter non-const?
+ ((LilvState*)state)->dir = lilv_strdup(dir);
+
+ char* const manifest = lilv_strjoin(dir, "/manifest.ttl", NULL);
+
SerdEnv* env = serd_env_new(NULL);
serd_env_set_prefix_from_strings(env, USTR("lv2"), USTR(LILV_NS_LV2));
serd_env_set_prefix_from_strings(env, USTR("pset"), USTR(NS_PSET));
@@ -776,6 +943,27 @@ lilv_state_save(LilvWorld* world,
serd_writer_end_anon(writer, &port);
}
+ // Create symlinks to external files
+#ifdef HAVE_LV2_STATE
+ for (ZixTreeIter* i = zix_tree_begin(state->abs2rel);
+ i != zix_tree_end(state->abs2rel);
+ i = zix_tree_iter_next(i)) {
+ const PathMap* pm = (const PathMap*)zix_tree_get(i);
+
+ char* real_dir = lilv_strjoin(realpath(dir, NULL), "/", NULL);
+ char* rel_path = lilv_strjoin(dir, "/", pm->rel, NULL);
+ char* target_path = lilv_path_is_child(pm->abs, state->file_dir)
+ ? lilv_path_relative_to(pm->abs, real_dir)
+ : lilv_strdup(pm->abs);
+ if (symlink(target_path, rel_path)) {
+ LILV_ERRORF("Failed to link `%s' => `%s' (%s)\n",
+ pm->abs, pm->rel, strerror(errno));
+ }
+ free(target_path);
+ free(rel_path);
+ }
+#endif
+
// Save properties
const SerdNode state_node = serd_node_from_string(SERD_BLANK,
USTR("2state"));
@@ -793,11 +981,6 @@ lilv_state_save(LilvWorld* world,
LILV_WARNF("Failed to unmap property key `%d'\n", prop->key);
} else if (!type) {
LILV_WARNF("Failed to unmap property type `%d'\n", prop->type);
-#ifdef HAVE_LV2_STATE
- } else if (!(prop->flags & LV2_STATE_IS_PORTABLE)
- || !(prop->flags & LV2_STATE_IS_POD)) {
- LILV_WARNF("Unable to save non-portable property <%s>\n", type);
-#endif
} else {
SerdNode t;
p = serd_node_from_string(SERD_URI, USTR(key));
@@ -805,10 +988,20 @@ lilv_state_save(LilvWorld* world,
world, unmap, type, prop->value, prop->size);
if (node) {
node_to_serd(node, &o, &t);
+ // <state> <key> value
serd_writer_write_statement(
writer, SERD_ANON_CONT, NULL,
&state_node, &p, &o, &t, NULL);
lilv_node_free(node);
+#ifdef HAVE_LV2_STATE
+ } else if (!strcmp(type, NS_STATE "Path")) {
+ o = serd_node_from_string(SERD_LITERAL, prop->value);
+ t = serd_node_from_string(SERD_URI, (const uint8_t*)type);
+ // <state> <key> "the/path"^^<state:Path>
+ serd_writer_write_statement(
+ writer, SERD_ANON_CONT, NULL,
+ &state_node, &p, &o, &t, NULL);
+#endif
} else {
char name[16];
snprintf(name, sizeof(name), "b%u", i);
@@ -817,24 +1010,22 @@ lilv_state_save(LilvWorld* world,
// <state> <key> [
serd_writer_write_statement(
- writer, SERD_ANON_O_BEGIN, NULL,
+ writer, SERD_ANON_CONT|SERD_ANON_O_BEGIN, NULL,
&state_node, &p, &blank, NULL, NULL);
// rdf:type <type>
p = serd_node_from_string(SERD_URI, USTR(LILV_NS_RDF "type"));
o = serd_node_from_string(SERD_URI, USTR(type));
- serd_writer_write_statement(
- writer, SERD_ANON_CONT, NULL,
- &blank, &p, &o, NULL, NULL);
+ serd_writer_write_statement(writer, SERD_ANON_CONT, NULL,
+ &blank, &p, &o, NULL, NULL);
// rdf:value "string"^^<xsd:base64Binary>
SerdNode blob = serd_node_new_blob(prop->value, prop->size, true);
p = serd_node_from_string(SERD_URI, USTR(LILV_NS_RDF "value"));
t = serd_node_from_string(SERD_URI,
USTR(LILV_NS_XSD "base64Binary"));
- serd_writer_write_statement(
- writer, SERD_ANON_CONT, NULL,
- &blank, &p, &blob, &t, NULL);
+ serd_writer_write_statement(writer, SERD_ANON_CONT, NULL,
+ &blank, &p, &blob, &t, NULL);
serd_node_free(&blob);
serd_writer_end_anon(writer, &blank); // ]
@@ -850,13 +1041,12 @@ lilv_state_save(LilvWorld* world,
fclose(fd);
serd_env_free(env);
- if (manifest_path) {
- add_state_to_manifest(
- state->plugin_uri, manifest_path, uri, path);
+ if (manifest) {
+ add_state_to_manifest(state->plugin_uri, manifest, uri, path);
}
- free(default_path);
- free(default_manifest_path);
+ free(default_dir);
+ free(default_filename);
return 0;
}
@@ -873,9 +1063,13 @@ lilv_state_free(LilvState* state)
free(state->values[i].symbol);
}
lilv_node_free(state->plugin_uri);
+ zix_tree_free(state->abs2rel);
+ zix_tree_free(state->rel2abs);
free(state->props);
free(state->values);
free(state->label);
+ free(state->dir);
+ free(state->file_dir);
free(state);
}
}
@@ -906,11 +1100,25 @@ lilv_state_equals(const LilvState* a, const LilvState* b)
for (uint32_t i = 0; i < a->num_props; ++i) {
Property* const ap = &a->props[i];
Property* const bp = &b->props[i];
- if (ap->size != bp->size
- || ap->key != bp->key
+ if (ap->key != bp->key
|| ap->type != bp->type
- || ap->flags != bp->flags
- || memcmp(ap->value, bp->value, ap->size)) {
+ || ap->flags != bp->flags) {
+ return false;
+ }
+
+ if (ap->type == a->state_Path) {
+ const char* const a_abs = lilv_state_rel2abs(a, ap->value);
+ const char* const b_abs = lilv_state_rel2abs(b, bp->value);
+ char* const a_real = realpath(a_abs, NULL);
+ char* const b_real = realpath(b_abs, NULL);
+ const int cmp = strcmp(a_real, b_real);
+ free(a_real);
+ free(b_real);
+ if (cmp) {
+ return false;
+ }
+ } else if (ap->size != bp->size
+ || memcmp(ap->value, bp->value, ap->size)) {
return false;
}
}