aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--include/serd/serd.h20
-rw-r--r--src/node.c82
-rw-r--r--src/static_nodes.h38
-rw-r--r--test/test_node.c34
4 files changed, 135 insertions, 39 deletions
diff --git a/include/serd/serd.h b/include/serd/serd.h
index 604b8032..c2c9d52d 100644
--- a/include/serd/serd.h
+++ b/include/serd/serd.h
@@ -561,15 +561,23 @@ serd_new_file_uri(SerdStringView path, SerdStringView hostname);
@param d The value for the new node.
@param frac_digits The maximum number of digits after the decimal place.
+ @param datatype Datatype of node, or NULL for xsd:decimal.
*/
SERD_API
SerdNode* SERD_ALLOCATED
-serd_new_decimal(double d, unsigned frac_digits);
+serd_new_decimal(double d,
+ unsigned frac_digits,
+ const SerdNode* SERD_NULLABLE datatype);
-/// Create a new node by serialising `i` into an xsd:integer string
+/**
+ Create a new node by serialising `i` into an xsd:integer string.
+
+ @param i Integer value to serialise.
+ @param datatype Datatype of node, or NULL for xsd:integer.
+*/
SERD_API
SerdNode* SERD_ALLOCATED
-serd_new_integer(int64_t i);
+serd_new_integer(int64_t i, const SerdNode* SERD_NULLABLE datatype);
/**
Create a node by serialising `buf` into an xsd:base64Binary string
@@ -580,10 +588,14 @@ serd_new_integer(int64_t i);
@param buf Raw binary input data.
@param size Size of `buf`.
@param wrap_lines Wrap lines at 76 characters to conform to RFC 2045.
+ @param datatype Datatype of node, or NULL for xsd:base64Binary.
*/
SERD_API
SerdNode* SERD_ALLOCATED
-serd_new_blob(const void* SERD_NONNULL buf, size_t size, bool wrap_lines);
+serd_new_blob(const void* SERD_NONNULL buf,
+ size_t size,
+ bool wrap_lines,
+ const SerdNode* SERD_NULLABLE datatype);
/// Return a deep copy of `node`
SERD_API
diff --git a/src/node.c b/src/node.c
index 09ff2b95..4728c39e 100644
--- a/src/node.c
+++ b/src/node.c
@@ -18,6 +18,7 @@
#include "base64.h"
#include "serd_internal.h"
+#include "static_nodes.h"
#include "string_utils.h"
#include "serd/serd.h"
@@ -48,8 +49,22 @@ serd_new_from_uri(const SerdURIView uri, const SerdURIView base);
static size_t
serd_node_pad_size(const size_t n_bytes)
{
- const size_t pad = serd_node_align - (n_bytes + 2) % serd_node_align;
- return n_bytes + 2 + pad;
+ const size_t pad = serd_node_align - (n_bytes + 2) % serd_node_align;
+ const size_t size = n_bytes + 2 + pad;
+ assert(size % serd_node_align == 0);
+ return size;
+}
+
+static const SerdNode*
+serd_node_meta_c(const SerdNode* node)
+{
+ return node + 1 + (serd_node_pad_size(node->n_bytes) / serd_node_align);
+}
+
+static SerdNode*
+serd_node_meta(SerdNode* node)
+{
+ return node + 1 + (serd_node_pad_size(node->n_bytes) / serd_node_align);
}
static const SerdNode*
@@ -383,21 +398,26 @@ serd_digits(double abs)
}
SerdNode*
-serd_new_decimal(double d, unsigned frac_digits)
+serd_new_decimal(double d, unsigned frac_digits, const SerdNode* datatype)
{
if (isnan(d) || isinf(d)) {
return NULL;
}
+ const SerdNode* type = datatype ? datatype : &serd_xsd_decimal.node;
const double abs_d = fabs(d);
const unsigned int_digits = serd_digits(abs_d);
const size_t len = int_digits + frac_digits + 3;
- SerdNode* const node = serd_node_malloc(len, 0, SERD_LITERAL);
- char* const buf = serd_node_buffer(node);
- const double int_part = floor(abs_d);
+ const size_t type_len = serd_node_total_size(type);
+ const size_t total_len = len + type_len;
+
+ SerdNode* const node =
+ serd_node_malloc(total_len, SERD_HAS_DATATYPE, SERD_LITERAL);
// Point s to decimal point location
- char* s = buf + int_digits;
+ char* const buf = serd_node_buffer(node);
+ const double int_part = floor(abs_d);
+ char* s = buf + int_digits;
if (d < 0.0) {
*buf = '-';
++s;
@@ -435,19 +455,24 @@ serd_new_decimal(double d, unsigned frac_digits)
}
}
+ memcpy(serd_node_meta(node), type, type_len);
return node;
}
SerdNode*
-serd_new_integer(int64_t i)
+serd_new_integer(int64_t i, const SerdNode* datatype)
{
- uint64_t abs_i = (i < 0) ? -i : i;
- const unsigned digits = serd_digits((double)abs_i);
- SerdNode* node = serd_node_malloc(digits + 2, 0, SERD_LITERAL);
- char* buf = serd_node_buffer(node);
+ const SerdNode* type = datatype ? datatype : &serd_xsd_integer.node;
+ uint64_t abs_i = (uint64_t)((i < 0) ? -i : i);
+ const unsigned digits = serd_digits((double)abs_i);
+ const size_t type_len = serd_node_total_size(type);
+ const size_t total_len = digits + 2 + type_len;
+
+ SerdNode* node = serd_node_malloc(total_len, SERD_HAS_DATATYPE, SERD_LITERAL);
// Point s to the end
- char* s = buf + digits - 1;
+ char* buf = serd_node_buffer(node);
+ char* s = buf + digits - 1;
if (i < 0) {
*buf = '-';
++s;
@@ -460,25 +485,35 @@ serd_new_integer(int64_t i)
*s-- = (char)('0' + (abs_i % 10));
} while ((abs_i /= 10) > 0);
+ memcpy(serd_node_meta(node), type, type_len);
return node;
}
SerdNode*
-serd_new_blob(const void* buf, size_t size, bool wrap_lines)
+serd_new_blob(const void* buf,
+ size_t size,
+ bool wrap_lines,
+ const SerdNode* datatype)
{
if (!buf || !size) {
return NULL;
}
- const size_t len = serd_base64_get_length(size, wrap_lines);
- SerdNode* node = serd_node_malloc(len + 1, 0, SERD_LITERAL);
- uint8_t* str = (uint8_t*)serd_node_buffer(node);
+ const SerdNode* type = datatype ? datatype : &serd_xsd_base64Binary.node;
+ const size_t len = serd_base64_get_length(size, wrap_lines);
+ const size_t type_len = serd_node_total_size(type);
+ const size_t total_len = len + 1 + type_len;
+ SerdNode* const node =
+ serd_node_malloc(total_len, SERD_HAS_DATATYPE, SERD_LITERAL);
+
+ uint8_t* str = (uint8_t*)serd_node_buffer(node);
if (serd_base64_encode(str, buf, size, wrap_lines)) {
node->flags |= SERD_HAS_NEWLINE;
}
node->n_bytes = len;
+ memcpy(serd_node_meta(node), type, type_len);
return node;
}
@@ -521,15 +556,6 @@ serd_node_uri_view(const SerdNode* SERD_NONNULL node)
: SERD_URI_NULL;
}
-static const SerdNode*
-serd_node_meta_node(const SerdNode* node)
-{
- const size_t len = serd_node_pad_size(node->n_bytes);
- assert((intptr_t)node % serd_node_align == 0);
- assert(len % serd_node_align == 0);
- return node + 1 + (len / serd_node_align);
-}
-
const SerdNode*
serd_node_datatype(const SerdNode* node)
{
@@ -537,7 +563,7 @@ serd_node_datatype(const SerdNode* node)
return NULL;
}
- const SerdNode* const datatype = serd_node_meta_node(node);
+ const SerdNode* const datatype = serd_node_meta_c(node);
assert(datatype->type == SERD_URI || datatype->type == SERD_CURIE);
return datatype;
}
@@ -549,7 +575,7 @@ serd_node_language(const SerdNode* node)
return NULL;
}
- const SerdNode* const lang = serd_node_meta_node(node);
+ const SerdNode* const lang = serd_node_meta_c(node);
assert(lang->type == SERD_LITERAL);
return lang;
}
diff --git a/src/static_nodes.h b/src/static_nodes.h
new file mode 100644
index 00000000..1b1fc062
--- /dev/null
+++ b/src/static_nodes.h
@@ -0,0 +1,38 @@
+/*
+ Copyright 2019-2020 David Robillard <d@drobilla.net>
+
+ Permission to use, copy, modify, and/or distribute this software for any
+ purpose with or without fee is hereby granted, provided that the above
+ copyright notice and this permission notice appear in all copies.
+
+ THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef SERD_STATIC_NODES_H
+#define SERD_STATIC_NODES_H
+
+#include "serd/serd.h"
+
+#include "node.h"
+#include "serd_internal.h"
+
+typedef struct StaticNode {
+ SerdNode node;
+ char buf[sizeof(NS_XSD "base64Binary")];
+} StaticNode;
+
+#define DEFINE_XSD_NODE(name) \
+ static const StaticNode serd_xsd_##name = { \
+ {sizeof(NS_XSD #name) - 1, 0, SERD_URI}, NS_XSD #name};
+
+DEFINE_XSD_NODE(base64Binary)
+DEFINE_XSD_NODE(decimal)
+DEFINE_XSD_NODE(integer)
+
+#endif // SERD_STATIC_NODES_H
diff --git a/test/test_node.c b/test/test_node.c
index eeafe5fc..93a408d6 100644
--- a/test/test_node.c
+++ b/test/test_node.c
@@ -34,6 +34,8 @@
# define NAN (INFINITY - INFINITY)
#endif
+#define NS_XSD "http://www.w3.org/2001/XMLSchema#"
+
static void
test_strtod(double dbl, double max_delta)
{
@@ -91,14 +93,23 @@ test_double_to_node(void)
NULL};
for (size_t i = 0; i < sizeof(dbl_test_nums) / sizeof(double); ++i) {
- SerdNode* node = serd_new_decimal(dbl_test_nums[i], 8);
+ SerdNode* node = serd_new_decimal(dbl_test_nums[i], 8, NULL);
const char* node_str = node ? serd_node_string(node) : NULL;
const bool pass = (node_str && dbl_test_strs[i])
? !strcmp(node_str, dbl_test_strs[i])
: (node_str == dbl_test_strs[i]);
assert(pass);
- assert(!node || serd_node_length(node) == strlen(node_str));
- serd_node_free(node);
+
+ const size_t len = node_str ? strlen(node_str) : 0;
+ assert((!node && len == 0) || serd_node_length(node) == len);
+
+ if (node) {
+ const SerdNode* const datatype = serd_node_datatype(node);
+ assert(datatype);
+ assert(!dbl_test_strs[i] ||
+ !strcmp(serd_node_string(datatype), NS_XSD "decimal"));
+ serd_node_free(node);
+ }
}
}
@@ -111,10 +122,15 @@ test_integer_to_node(void)
"0", "0", "-23", "23", "-12340", "1000", "-1000"};
for (size_t i = 0; i < sizeof(int_test_nums) / sizeof(double); ++i) {
- SerdNode* node = serd_new_integer(int_test_nums[i]);
+ SerdNode* node = serd_new_integer(int_test_nums[i], NULL);
const char* node_str = serd_node_string(node);
assert(!strcmp(node_str, int_test_strs[i]));
- assert(serd_node_length(node) == strlen(node_str));
+ const size_t len = strlen(node_str);
+ assert(serd_node_length(node) == len);
+
+ const SerdNode* const datatype = serd_node_datatype(node);
+ assert(datatype);
+ assert(!strcmp(serd_node_string(datatype), NS_XSD "integer"));
serd_node_free(node);
}
}
@@ -122,7 +138,7 @@ test_integer_to_node(void)
static void
test_blob_to_node(void)
{
- assert(!serd_new_blob(&SERD_URI_NULL, 0, false));
+ assert(!serd_new_blob(&SERD_URI_NULL, 0, false, NULL));
for (size_t size = 1; size < 256; ++size) {
uint8_t* const data = (uint8_t*)malloc(size);
@@ -131,7 +147,7 @@ test_blob_to_node(void)
}
size_t out_size = 0;
- SerdNode* blob = serd_new_blob(data, size, size % 5);
+ SerdNode* blob = serd_new_blob(data, size, size % 5, NULL);
const char* blob_str = serd_node_string(blob);
uint8_t* out =
(uint8_t*)serd_base64_decode(blob_str, serd_node_length(blob), &out_size);
@@ -143,6 +159,10 @@ test_blob_to_node(void)
assert(out[i] == data[i]);
}
+ const SerdNode* const datatype = serd_node_datatype(blob);
+ assert(datatype);
+ assert(!strcmp(serd_node_string(datatype), NS_XSD "base64Binary"));
+
serd_node_free(blob);
serd_free(out);
free(data);