Set datatypes on integer, decimal, and base64 nodes

4 files changed, 129 insertions, 38 deletions

diff --git a/serd/serd.h b/serd/serd.h
index 513ac7dc..bf1ac8d5 100644
--- a/serd/serd.h
+++ b/serd/serd.h
@@ -582,18 +582,27 @@ serd_node_new_relative_uri(const char*     str,
    represent a double and float, respectively.
 
    @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, may be NULL in which case the node has
+   type xsd:decimal.
 */
 SERD_API
 SerdNode*
-serd_node_new_decimal(double d, unsigned frac_digits);
+serd_node_new_decimal(double d, unsigned frac_digits, const SerdNode* datatype);
 
 /**
    Create a new node by serialising `i` into an xsd:integer string.
+
+   @param i Integer value to serialise.
+
+   @param datatype Datatype of node, may be NULL in which case the node has
+   type xsd:integer.
 */
 SERD_API
 SerdNode*
-serd_node_new_integer(int64_t i);
+serd_node_new_integer(int64_t i, const SerdNode* datatype);
 
 /**
    Create a node by serialising `buf` into an xsd:base64Binary string.
@@ -601,12 +610,19 @@ serd_node_new_integer(int64_t i);
    binary data, which can be decoded using serd_base64_decode().
 
    @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, may be NULL in which case the node has
+   type xsd:base64Binary.
 */
 SERD_API
-SerdNode*
-serd_node_new_blob(const void* buf, size_t size, bool wrap_lines);
+SerdNode* serd_node_new_blob(const void*     buf,
+                             size_t          size,
+                             bool            wrap_lines,
+                             const SerdNode* datatype);
 
 /**
    Return a deep copy of `node`.
diff --git a/src/node.c b/src/node.c
index 2bb1d493..96afc075 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"
@@ -49,7 +50,21 @@ 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 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*
@@ -413,21 +428,26 @@ serd_digits(double abs)
 }
 
 SerdNode*
-serd_node_new_decimal(double d, unsigned frac_digits)
+serd_node_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;
@@ -465,19 +485,25 @@ serd_node_new_decimal(double d, unsigned frac_digits)
 		}
 	}
 
+	memcpy(serd_node_meta(node), type, type_len);
 	return node;
 }
 
 SerdNode*
-serd_node_new_integer(int64_t i)
+serd_node_new_integer(int64_t i, const SerdNode* datatype)
 {
-	int64_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;
@@ -490,25 +516,35 @@ serd_node_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_node_new_blob(const void* buf, size_t size, bool wrap_lines)
+serd_node_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;
 }
 
@@ -530,15 +566,6 @@ serd_node_length(const SerdNode* node)
 	return node ? node->n_bytes : 0;
 }
 
-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)
 {
@@ -546,7 +573,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;
 }
@@ -558,7 +585,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..62e38c91
--- /dev/null
+++ b/src/static_nodes.h
@@ -0,0 +1,36 @@
+/*
+  Copyright 2019-2020 David Robillard <http://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 "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/tests/serd_test.c b/tests/serd_test.c
index 168c4ee8..72f5db84 100644
--- a/tests/serd_test.c
+++ b/tests/serd_test.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)
 {
@@ -270,13 +272,17 @@ test_double_to_node(void)
 	};
 
 	for (size_t i = 0; i < sizeof(dbl_test_nums) / sizeof(double); ++i) {
-		SerdNode*   node     = serd_node_new_decimal(dbl_test_nums[i], 8);
+		SerdNode*   node     = serd_node_new_decimal(dbl_test_nums[i], 8, NULL);
 		const char* node_str = serd_node_string(node);
 		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(serd_node_length(node) == (node_str ? strlen(node_str) : 0));
+		const size_t len = node_str ? strlen(node_str) : 0;
+		assert(serd_node_length(node) == len);
+		assert(!dbl_test_strs[i] ||
+		       !strcmp(serd_node_string(serd_node_datatype(node)),
+		               NS_XSD "decimal"));
 		serd_node_free(node);
 	}
 }
@@ -293,10 +299,13 @@ test_integer_to_node(void)
 	};
 
 	for (size_t i = 0; i < sizeof(int_test_nums) / sizeof(double); ++i) {
-		SerdNode*   node     = serd_node_new_integer(int_test_nums[i]);
+		SerdNode*   node     = serd_node_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);
+		assert(!strcmp(serd_node_string(serd_node_datatype(node)),
+		               NS_XSD "integer"));
 		serd_node_free(node);
 	}
 }
@@ -304,8 +313,8 @@ test_integer_to_node(void)
 static void
 test_blob_to_node(void)
 {
-	assert(!serd_node_new_blob(NULL, 0, true));
-	assert(!serd_node_new_blob("data", 0, true));
+	assert(!serd_node_new_blob(NULL, 0, true, NULL));
+	assert(!serd_node_new_blob("data", 0, true, NULL));
 
 	for (size_t size = 1; size < 256; ++size) {
 		uint8_t* data = size > 0 ? (uint8_t*)malloc(size) : NULL;
@@ -314,7 +323,7 @@ test_blob_to_node(void)
 		}
 
 		size_t      out_size = 0;
-		SerdNode*   blob     = serd_node_new_blob(data, size, size % 5);
+		SerdNode*   blob     = serd_node_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);
@@ -326,6 +335,9 @@ test_blob_to_node(void)
 			assert(out[i] == data[i]);
 		}
 
+		assert(!strcmp(serd_node_string(serd_node_datatype(blob)),
+		               NS_XSD "base64Binary"));
+
 		serd_node_free(blob);
 		serd_free(out);
 		free(data);