From 247affdf0f48edcae95188e96ddad0f80ee09617 Mon Sep 17 00:00:00 2001 From: David Robillard Date: Sat, 26 May 2018 15:29:48 +0200 Subject: WIP: Port to serd1 --- src/node.c | 320 +++++++++++++------------------------------------------------ 1 file changed, 69 insertions(+), 251 deletions(-) (limited to 'src/node.c') diff --git a/src/node.c b/src/node.c index ac47e80..f10ed91 100644 --- a/src/node.c +++ b/src/node.c @@ -19,283 +19,103 @@ #include "lilv/lilv.h" #include "serd/serd.h" -#include "sord/sord.h" #include #include -#include #include #include #include -static void -lilv_node_set_numerics_from_string(LilvNode* val) -{ - const char* str = (const char*)sord_node_get_string(val->node); - - switch (val->type) { - case LILV_VALUE_URI: - case LILV_VALUE_BLANK: - case LILV_VALUE_STRING: - case LILV_VALUE_BLOB: - break; - case LILV_VALUE_INT: - val->val.int_val = strtol(str, NULL, 10); - break; - case LILV_VALUE_FLOAT: - val->val.float_val = serd_strtod(str, NULL); - break; - case LILV_VALUE_BOOL: - val->val.bool_val = !strcmp(str, "true"); - break; - } -} - -/** Note that if `type` is numeric or boolean, the returned value is corrupt - * until lilv_node_set_numerics_from_string is called. It is not - * automatically called from here to avoid overhead and imprecision when the - * exact string value is known. - */ -LilvNode* -lilv_node_new(LilvWorld* world, LilvNodeType type, const char* str) -{ - LilvNode* val = (LilvNode*)malloc(sizeof(LilvNode)); - val->world = world; - val->type = type; - - const uint8_t* ustr = (const uint8_t*)str; - switch (type) { - case LILV_VALUE_URI: - val->node = sord_new_uri(world->world, ustr); - break; - case LILV_VALUE_BLANK: - val->node = sord_new_blank(world->world, ustr); - break; - case LILV_VALUE_STRING: - val->node = sord_new_literal(world->world, NULL, ustr, NULL); - break; - case LILV_VALUE_INT: - val->node = - sord_new_literal(world->world, world->uris.xsd_integer, ustr, NULL); - break; - case LILV_VALUE_FLOAT: - val->node = - sord_new_literal(world->world, world->uris.xsd_decimal, ustr, NULL); - break; - case LILV_VALUE_BOOL: - val->node = - sord_new_literal(world->world, world->uris.xsd_boolean, ustr, NULL); - break; - case LILV_VALUE_BLOB: - val->node = - sord_new_literal(world->world, world->uris.xsd_base64Binary, ustr, NULL); - break; - } - - if (!val->node) { - free(val); - return NULL; - } - - return val; -} - -/** Create a new LilvNode from `node`, or return NULL if impossible */ -LilvNode* -lilv_node_new_from_node(LilvWorld* world, const SordNode* node) -{ - if (!node) { - return NULL; - } - - LilvNode* result = NULL; - SordNode* datatype_uri = NULL; - LilvNodeType type = LILV_VALUE_STRING; - - switch (sord_node_get_type(node)) { - case SORD_URI: - result = (LilvNode*)malloc(sizeof(LilvNode)); - result->world = world; - result->type = LILV_VALUE_URI; - result->node = sord_node_copy(node); - break; - case SORD_BLANK: - result = (LilvNode*)malloc(sizeof(LilvNode)); - result->world = world; - result->type = LILV_VALUE_BLANK; - result->node = sord_node_copy(node); - break; - case SORD_LITERAL: - datatype_uri = sord_node_get_datatype(node); - if (datatype_uri) { - if (sord_node_equals(datatype_uri, world->uris.xsd_boolean)) { - type = LILV_VALUE_BOOL; - } else if (sord_node_equals(datatype_uri, world->uris.xsd_decimal) || - sord_node_equals(datatype_uri, world->uris.xsd_double)) { - type = LILV_VALUE_FLOAT; - } else if (sord_node_equals(datatype_uri, world->uris.xsd_integer)) { - type = LILV_VALUE_INT; - } else if (sord_node_equals(datatype_uri, world->uris.xsd_base64Binary)) { - type = LILV_VALUE_BLOB; - } else { - LILV_ERRORF("Unknown datatype `%s'\n", - sord_node_get_string(datatype_uri)); - } - } - result = - lilv_node_new(world, type, (const char*)sord_node_get_string(node)); - lilv_node_set_numerics_from_string(result); - break; - } - - return result; -} - +LILV_API LilvNode* lilv_new_uri(LilvWorld* world, const char* uri) { - return lilv_node_new(world, LILV_VALUE_URI, uri); + (void)world; + return serd_new_uri(SERD_MEASURE_STRING(uri)); } LilvNode* lilv_new_file_uri(LilvWorld* world, const char* host, const char* path) { - char* abs_path = lilv_path_absolute(path); - SerdNode s = serd_node_new_file_uri( - (const uint8_t*)abs_path, (const uint8_t*)host, NULL, true); + (void)world; + + char* abs_path = lilv_path_absolute(path); + SerdNode* s = + serd_new_file_uri(SERD_MEASURE_STRING(abs_path), SERD_MEASURE_STRING(host)); - LilvNode* ret = lilv_node_new(world, LILV_VALUE_URI, (const char*)s.buf); - serd_node_free(&s); free(abs_path); - return ret; + return s; } LilvNode* lilv_new_string(LilvWorld* world, const char* str) { - return lilv_node_new(world, LILV_VALUE_STRING, str); + (void)world; + + return serd_new_string(SERD_MEASURE_STRING(str)); } LilvNode* lilv_new_int(LilvWorld* world, int val) { - char str[32]; - snprintf(str, sizeof(str), "%d", val); - LilvNode* ret = lilv_node_new(world, LILV_VALUE_INT, str); - if (ret) { - ret->val.int_val = val; - } - return ret; + (void)world; + + return serd_new_integer(val, world->uris.xsd_int); } LilvNode* lilv_new_float(LilvWorld* world, float val) { - char str[32]; - snprintf(str, sizeof(str), "%f", val); - LilvNode* ret = lilv_node_new(world, LILV_VALUE_FLOAT, str); - if (ret) { - ret->val.float_val = val; - } - return ret; + (void)world; + + return serd_new_float(val); } LilvNode* lilv_new_bool(LilvWorld* world, bool val) { - LilvNode* ret = lilv_node_new(world, LILV_VALUE_BOOL, val ? "true" : "false"); - if (ret) { - ret->val.bool_val = val; - } - return ret; + (void)world; + + return serd_new_typed_literal(val ? SERD_STATIC_STRING("true") + : SERD_STATIC_STRING("false"), + serd_node_string_view(world->uris.xsd_boolean)); } LilvNode* lilv_node_duplicate(const LilvNode* val) { - if (!val) { - return NULL; - } - - LilvNode* result = (LilvNode*)malloc(sizeof(LilvNode)); - result->world = val->world; - result->node = sord_node_copy(val->node); - result->val = val->val; - result->type = val->type; - return result; + return serd_node_copy(val); } void lilv_node_free(LilvNode* val) { - if (val) { - sord_node_free(val->world->world, val->node); - free(val); - } + serd_node_free(val); } bool lilv_node_equals(const LilvNode* value, const LilvNode* other) { - if (value == NULL && other == NULL) { - return true; - } - - if (value == NULL || other == NULL || value->type != other->type) { - return false; - } - - switch (value->type) { - case LILV_VALUE_URI: - case LILV_VALUE_BLANK: - case LILV_VALUE_STRING: - case LILV_VALUE_BLOB: - return sord_node_equals(value->node, other->node); - case LILV_VALUE_INT: - return (value->val.int_val == other->val.int_val); - case LILV_VALUE_FLOAT: - return (value->val.float_val == other->val.float_val); - case LILV_VALUE_BOOL: - return (value->val.bool_val == other->val.bool_val); - } - - return false; /* shouldn't get here */ + return serd_node_equals(value, other); } char* lilv_node_get_turtle_token(const LilvNode* value) { - const char* str = (const char*)sord_node_get_string(value->node); + const char* str = serd_node_string(value); size_t len = 0; char* result = NULL; - SerdNode node; - switch (value->type) { - case LILV_VALUE_URI: + if (lilv_node_is_uri(value)) { len = strlen(str) + 3; result = (char*)calloc(len, 1); snprintf(result, len, "<%s>", str); - break; - case LILV_VALUE_BLANK: + } else if (lilv_node_is_blank(value)) { len = strlen(str) + 3; result = (char*)calloc(len, 1); snprintf(result, len, "_:%s", str); - break; - case LILV_VALUE_STRING: - case LILV_VALUE_BOOL: - case LILV_VALUE_BLOB: + } else { result = lilv_strdup(str); - break; - case LILV_VALUE_INT: - node = serd_node_new_integer(value->val.int_val); - result = lilv_strdup((char*)node.buf); - serd_node_free(&node); - break; - case LILV_VALUE_FLOAT: - node = serd_node_new_decimal(value->val.float_val, 8); - result = lilv_strdup((char*)node.buf); - serd_node_free(&node); - break; } return result; @@ -304,110 +124,108 @@ lilv_node_get_turtle_token(const LilvNode* value) bool lilv_node_is_uri(const LilvNode* value) { - return (value && value->type == LILV_VALUE_URI); + return value && serd_node_type(value) == SERD_URI; } const char* lilv_node_as_uri(const LilvNode* value) { - return (lilv_node_is_uri(value) - ? (const char*)sord_node_get_string(value->node) - : NULL); + return (lilv_node_is_uri(value) ? serd_node_string(value) : NULL); } bool lilv_node_is_blank(const LilvNode* value) { - return (value && value->type == LILV_VALUE_BLANK); + return value && serd_node_type(value) == SERD_BLANK; } const char* lilv_node_as_blank(const LilvNode* value) { - return (lilv_node_is_blank(value) - ? (const char*)sord_node_get_string(value->node) - : NULL); + return (lilv_node_is_blank(value) ? serd_node_string(value) : NULL); } bool lilv_node_is_literal(const LilvNode* value) { - if (!value) { - return false; - } - - switch (value->type) { - case LILV_VALUE_STRING: - case LILV_VALUE_INT: - case LILV_VALUE_FLOAT: - case LILV_VALUE_BLOB: - return true; - default: - return false; - } + return value && serd_node_type(value) == SERD_LITERAL; } bool lilv_node_is_string(const LilvNode* value) { - return (value && value->type == LILV_VALUE_STRING); + return value && + (serd_node_type(value) == SERD_LITERAL && !serd_node_datatype(value)); } const char* lilv_node_as_string(const LilvNode* value) { - return value ? (const char*)sord_node_get_string(value->node) : NULL; + return value ? serd_node_string(value) : NULL; } bool lilv_node_is_int(const LilvNode* value) { - return (value && value->type == LILV_VALUE_INT); + if (!value) { + return false; + } + + const SerdNode* const datatype = serd_node_datatype(value); + return (serd_node_type(value) == SERD_LITERAL && datatype && + (!strcmp(serd_node_string(datatype), LILV_NS_XSD "integer") || + !strcmp(serd_node_string(datatype), LILV_NS_XSD "int"))); } int lilv_node_as_int(const LilvNode* value) { - return lilv_node_is_int(value) ? value->val.int_val : 0; + return lilv_node_is_int(value) ? strtoll(serd_node_string(value), NULL, 10) + : 0; } bool lilv_node_is_float(const LilvNode* value) { - return (value && value->type == LILV_VALUE_FLOAT); + if (!value) { + return false; + } + + const SerdNode* const datatype = serd_node_datatype(value); + return (serd_node_type(value) == SERD_LITERAL && datatype && + (!strcmp(serd_node_string(datatype), LILV_NS_XSD "decimal") || + !strcmp(serd_node_string(datatype), LILV_NS_XSD "float") || + !strcmp(serd_node_string(datatype), LILV_NS_XSD "double"))); } float lilv_node_as_float(const LilvNode* value) { - if (lilv_node_is_float(value)) { - return value->val.float_val; - } - - if (lilv_node_is_int(value)) { - return (float)value->val.int_val; - } - - return NAN; + return serd_get_float(value); } bool lilv_node_is_bool(const LilvNode* value) { - return (value && value->type == LILV_VALUE_BOOL); + if (!value) { + return false; + } + + const SerdNode* const datatype = serd_node_datatype(value); + return (serd_node_type(value) == SERD_LITERAL && datatype && + (!strcmp(serd_node_string(datatype), LILV_NS_XSD "boolean"))); } bool lilv_node_as_bool(const LilvNode* value) { - return lilv_node_is_bool(value) ? value->val.bool_val : false; + return (lilv_node_is_bool(value) && !strcmp(serd_node_string(value), "true")); } char* lilv_node_get_path(const LilvNode* value, char** hostname) { - if (lilv_node_is_uri(value)) { - return lilv_file_uri_parse(lilv_node_as_uri(value), hostname); - } - return NULL; + return lilv_node_is_uri(value) + ? serd_parse_file_uri(lilv_node_as_uri(value), hostname) + : NULL; } -- cgit v1.2.1