Update serd

source/carla_skin.py

@@ -119,7 +119,8 @@ def getParameterShortName(paramName):
     elif "threshold" in paramLow:
         paramName = paramName.replace("hreshold", "hres")
 
-    # remove space if 1st last word is lowercase and the 2nd first is uppercase, or if 2nd is number
+    # remove space if last char from 1st word is lowercase and the first char from the 2nd is uppercase,
+    # or if 2nd is a number
     if " " in paramName:
         name1, name2 = paramName.split(" ", 1)
         if (name1[-1].islower() and name2[0].isupper()) or name2.isdigit():

source/modules/lilv/serd-0.20.0/NEWS

@@ -1,3 +1,17 @@
+serd (0.21.1) unstable;
+
+  * Remove dependence on fmax() to avoid portability issues
+  * Fix serd_reader_read_file() for URIs with escaped characters (spaces)
+  * Add serd_reader_set_strict() and -l (lax) option to serdi to tolerate
+    parsing URIs with escaped characters
+  * Fix reading statements ending with a blank then dot with no space
+  * Fix serializing fractional decimals that would round up
+  * Add support for Turtle named inline nodes extension
+  * Report errors for invalid IRI characters and missing terminators
+  * Fix warnings when building with ISO C++ compilers
+
+ -- David Robillard <d@drobilla.net>  Sat, 04 Apr 2015 16:22:17 -0400
+
 serd (0.20.0) stable;
 
   * Support new RDF 1.1 Turtle

source/modules/lilv/serd-0.20.0/serd.pc.in

@@ -6,6 +6,6 @@ includedir=@INCLUDEDIR@
 Name: Serd
 Version: @SERD_VERSION@
 Description: Lightweight RDF syntax library
-Libs: -L${libdir} -l@LIB_SERD@
+Libs: -L${libdir} -l@LIB_SERD@ -lm
 Libs.private: -lm
 Cflags: -I${includedir}/serd-@SERD_MAJOR_VERSION@

source/modules/lilv/serd-0.20.0/serd/serd.h

@@ -183,7 +183,7 @@ typedef enum {
 	   @see <a href="http://www.w3.org/TeamSubmission/turtle#nodeID">Turtle
 	   <tt>nodeID</tt></a>
 	*/
-	SERD_BLANK = 4,
+	SERD_BLANK = 4
 
 } SerdType;
 
@@ -317,7 +317,7 @@ serd_base64_decode(const uint8_t* str, size_t len, size_t* size);
    @{
 */
 
-static const SerdURI SERD_URI_NULL = {{NULL,0},{NULL,0},{NULL,0},{NULL,0},{NULL,0},{NULL,0}};
+static const SerdURI SERD_URI_NULL = {{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}};
 
 /**
    Return the local path for `uri`, or NULL if `uri` is not a file URI.
@@ -336,8 +336,7 @@ serd_uri_to_path(const uint8_t* uri);
    @param hostname If non-NULL, set to the hostname, if present.
    @return The path component of the URI.
 
-   Both the returned path and `hostname` (if applicable) are owned by the
-   caller and must be freed with free().
+   The returned path and `*hostname` must be freed with free().
 */
 SERD_API
 uint8_t*
@@ -397,7 +396,7 @@ serd_uri_serialise_relative(const SerdURI* uri,
    @{
 */
 
-static const SerdNode SERD_NODE_NULL = { NULL, 0, 0, 0, SERD_NOTHING };
+static const SerdNode SERD_NODE_NULL = { 0, 0, 0, 0, SERD_NOTHING };
 
 /**
    Make a (shallow) node from `str`.
@@ -688,6 +687,17 @@ serd_reader_new(SerdSyntax        syntax,
                 SerdStatementSink statement_sink,
                 SerdEndSink       end_sink);
 
+/**
+   Enable or disable strict parsing.
+
+   The reader is non-strict (lax) by default, which will tolerate URIs with
+   invalid characters.  Setting strict will fail when parsing such files.  An
+   error is printed for invalid input in either case.
+*/
+SERD_API
+void
+serd_reader_set_strict(SerdReader* reader, bool strict);
+
 /**
    Set a function to be called when errors occur during reading.
 

source/modules/lilv/serd-0.20.0/src/node.c

@@ -216,6 +216,13 @@ serd_node_new_uri(const SerdURI* uri, const SerdURI* base, SerdURI* out)
 	return node;
 }
 
+static inline unsigned
+serd_digits(double abs)
+{
+	const double lg = ceil(log10(floor(abs) + 1.0));
+	return lg < 1.0 ? 1U : (unsigned)lg;
+}
+
 SERD_API
 SerdNode
 serd_node_new_decimal(double d, unsigned frac_digits)
@@ -225,7 +232,7 @@ serd_node_new_decimal(double d, unsigned frac_digits)
 	}
 
 	const double   abs_d      = fabs(d);
-	const unsigned int_digits = (unsigned)fmax(1.0, ceil(log10(abs_d + 1)));
+	const unsigned int_digits = serd_digits(abs_d);
 	char*          buf        = (char*)calloc(int_digits + frac_digits + 3, 1);
 	SerdNode       node       = { (const uint8_t*)buf, 0, 0, 0, SERD_LITERAL };
 	const double   int_part   = floor(abs_d);
@@ -276,7 +283,7 @@ SerdNode
 serd_node_new_integer(int64_t i)
 {
 	int64_t        abs_i  = (i < 0) ? -i : i;
-	const unsigned digits = fmax(1.0, ceil(log10((double)abs_i + 1)));
+	const unsigned digits = serd_digits(abs_i);
 	char*          buf    = (char*)calloc(digits + 2, 1);
 	SerdNode       node   = { (const uint8_t*)buf, 0, 0, 0, SERD_LITERAL };
 

source/modules/lilv/serd-0.20.0/src/reader.c

@@ -17,6 +17,7 @@
 #include "serd_internal.h"
 
 #include <assert.h>
+#include <ctype.h>
 #include <errno.h>
 #include <stdarg.h>
 #include <stdint.h>
@@ -84,6 +85,7 @@ struct SerdReaderImpl {
 	uint8_t           read_byte;  ///< 1-byte 'buffer' used when not paging
 	bool              from_file;  ///< True iff reading from `fd`
 	bool              paging;     ///< True iff reading a page at a time
+	bool              strict;     ///< True iff strict parsing
 	bool              eof;
 	bool              seen_genid;
 #ifdef SERD_STACK_CHECK
@@ -802,7 +804,17 @@ read_IRIREF(SerdReader* reader)
 			break;
 		default:
 			if (c <= 0x20) {
-				return pop_node(reader, ref);
+				if (isprint(c)) {
+					r_err(reader, SERD_ERR_BAD_SYNTAX,
+					      "invalid IRI character `%c' (escape %%%02X)\n", c, c);
+				} else {
+					r_err(reader, SERD_ERR_BAD_SYNTAX,
+					      "invalid IRI character (escape %%%02X)\n", c, c);
+				}
+				if (reader->strict) {
+					return pop_node(reader, ref);
+				}
+				push_byte(reader, ref, eat_byte_safe(reader, c));
 			} else {
 				push_byte(reader, ref, eat_byte_safe(reader, c));
 			}
@@ -990,7 +1002,7 @@ read_verb(SerdReader* reader, Ref* dest)
 }
 
 static Ref
-read_BLANK_NODE_LABEL(SerdReader* reader)
+read_BLANK_NODE_LABEL(SerdReader* reader, bool* ate_dot)
 {
 	eat_byte_safe(reader, '_');
 	eat_byte_check(reader, ':');
@@ -1014,10 +1026,12 @@ read_BLANK_NODE_LABEL(SerdReader* reader)
 		}
 	}
 
-	const SerdNode* n = deref(reader, ref);
+	SerdNode* n = deref(reader, ref);
 	if (n->buf[n->n_bytes - 1] == '.' && !read_PN_CHARS(reader, ref)) {
-		r_err(reader, SERD_ERR_BAD_SYNTAX, "name ends with `.'\n");
-		return pop_node(reader, ref);
+		// Ate trailing dot, pop it from stack/node and inform caller
+		--n->n_bytes;
+		serd_stack_pop(&reader->stack, 1);
+		*ate_dot = true;
 	}
 
 	if (reader->syntax == SERD_TURTLE) {
@@ -1058,23 +1072,46 @@ blank_id(SerdReader* reader)
 	return ref;
 }
 
+static Ref
+read_blankName(SerdReader* reader)
+{
+	eat_byte_safe(reader, '=');
+	if (eat_byte_check(reader, '=') != '=') {
+		return r_err(reader, SERD_ERR_BAD_SYNTAX, "expected `='\n");
+	}
+
+	Ref  subject = 0;
+	bool ate_dot = false;
+	read_ws_star(reader);
+	read_iri(reader, &subject, &ate_dot);
+	return subject;
+}
+
 static bool
-read_blank(SerdReader* reader, ReadContext ctx, bool subject, Ref* dest)
+read_blank(SerdReader* reader, ReadContext ctx, bool subject, Ref* dest, bool* ate_dot)
 {
 	const SerdStatementFlags old_flags = *ctx.flags;
 	bool empty;
 	switch (peek_byte(reader)) {
 	case '_':
-		return (*dest = read_BLANK_NODE_LABEL(reader));
+		return (*dest = read_BLANK_NODE_LABEL(reader, ate_dot));
 	case '[':
 		eat_byte_safe(reader, '[');
 		if ((empty = peek_delim(reader, ']'))) {
 			*ctx.flags |= (subject) ? SERD_EMPTY_S : SERD_EMPTY_O;
 		} else {
 			*ctx.flags |= (subject) ? SERD_ANON_S_BEGIN : SERD_ANON_O_BEGIN;
+			if (peek_delim(reader, '=')) {
+				if (!(*dest = read_blankName(reader)) ||
+				    !eat_delim(reader, ';')) {
+					return false;
+				}
+			}
 		}
 
-		*dest = blank_id(reader);
+		if (!*dest) {
+			*dest = blank_id(reader);
+		}
 		if (ctx.subject) {
 			TRY_RET(emit_statement(reader, ctx, *dest, 0, 0));
 		}
@@ -1085,9 +1122,9 @@ read_blank(SerdReader* reader, ReadContext ctx, bool subject, Ref* dest)
 			if (!subject) {
 				*ctx.flags |= SERD_ANON_CONT;
 			}
-			bool ate_dot = false;
-			read_predicateObjectList(reader, ctx, &ate_dot);
-			if (ate_dot) {
+			bool ate_dot_in_list = false;
+			read_predicateObjectList(reader, ctx, &ate_dot_in_list);
+			if (ate_dot_in_list) {
 				return r_err(reader, SERD_ERR_BAD_SYNTAX, "`.' inside blank\n");
 			}
 			read_ws_star(reader);
@@ -1096,12 +1133,10 @@ read_blank(SerdReader* reader, ReadContext ctx, bool subject, Ref* dest)
 			}
 			*ctx.flags = old_flags;
 		}
-		eat_byte_check(reader, ']');
-		return true;
+		return (eat_byte_check(reader, ']') == ']');
 	case '(':
 		return read_collection(reader, ctx, dest);
-	default:
-		return r_err(reader, SERD_ERR_BAD_SYNTAX, "invalid blank node\n");
+	default: return false;  // never reached
 	}
 }
 
@@ -1133,7 +1168,7 @@ read_object(SerdReader* reader, ReadContext ctx, bool* ate_dot)
 		emit = false;
 		// fall through
 	case '_':
-		TRY_THROW(ret = read_blank(reader, ctx, false, &o));
+		TRY_THROW(ret = read_blank(reader, ctx, false, &o, ate_dot));
 		break;
 	case '<': case ':':
 		TRY_THROW(ret = read_iri(reader, &o, ate_dot));
@@ -1302,7 +1337,7 @@ read_subject(SerdReader* reader, ReadContext ctx, bool* nested)
 		*nested = true;
 		// nobreak
 	case '_':
-		read_blank(reader, ctx, true, &subject);
+		read_blank(reader, ctx, true, &subject, &ate_dot);
 		break;
 	default:
 		read_iri(reader, &subject, &ate_dot);
@@ -1320,10 +1355,10 @@ read_triples(SerdReader* reader, ReadContext ctx, bool* ate_dot)
 		ctx.subject = subject;
 		if (nested) {
 			read_ws_star(reader);
+			ret = true;
 			if (peek_byte(reader) != '.') {
-				read_predicateObjectList(reader, ctx, ate_dot);
+				ret = read_predicateObjectList(reader, ctx, ate_dot);
 			}
-			ret = true;
 		} else {
 			TRY_RET(read_ws_plus(reader));
 			ret = read_predicateObjectList(reader, ctx, ate_dot);
@@ -1411,14 +1446,15 @@ read_statement(SerdReader* reader)
 	case '@':
 		TRY_RET(read_directive(reader));
 		read_ws_star(reader);
-		return eat_byte_safe(reader, '.');
+		return (eat_byte_check(reader, '.') == '.');
 	default:
-		TRY_RET(read_triples(reader, ctx, &ate_dot));
-		if (ate_dot) {
+		if (!read_triples(reader, ctx, &ate_dot)) {
+			return false;
+		} else if (ate_dot) {
 			return true;
 		} else {
 			read_ws_star(reader);
-			return eat_byte_check(reader, '.');
+			return (eat_byte_check(reader, '.') == '.');
 		}
 		break;
 	}
@@ -1466,6 +1502,7 @@ serd_reader_new(SerdSyntax        syntax,
 	me->read_buf         = 0;
 	me->file_buf         = 0;
 	me->read_head        = 0;
+	me->strict           = false;
 	me->eof              = false;
 	me->seen_genid       = false;
 #ifdef SERD_STACK_CHECK
@@ -1480,6 +1517,13 @@ serd_reader_new(SerdSyntax        syntax,
 	return me;
 }
 
+SERD_API
+void
+serd_reader_set_strict(SerdReader* reader, bool strict)
+{
+	reader->strict = strict;
+}
+
 SERD_API
 void
 serd_reader_set_error_sink(SerdReader*   reader,
@@ -1546,18 +1590,20 @@ SerdStatus
 serd_reader_read_file(SerdReader*    reader,
                       const uint8_t* uri)
 {
-	const uint8_t* path = serd_uri_to_path(uri);
+	uint8_t* const path = serd_file_uri_parse(uri, NULL);
 	if (!path) {
 		return SERD_ERR_BAD_ARG;
 	}
 
 	FILE* fd = serd_fopen((const char*)path, "r");
 	if (!fd) {
+		free(path);
 		return SERD_ERR_UNKNOWN;
 	}
 
 	SerdStatus ret = serd_reader_read_file_handle(reader, fd, path);
 	fclose(fd);
+	free(path);
 	return ret;
 }
 

source/modules/lilv/serd-0.20.0/src/serd_internal.h

@@ -38,14 +38,6 @@
 #    define MIN(a, b) (((a) < (b)) ? (a) : (b))
 #endif
 
-#ifndef HAVE_FMAX
-static inline double
-fmax(double a, double b)
-{
-	return (a < b) ? b : a;
-}
-#endif
-
 /* File and Buffer Utilities */
 
 static inline FILE*

source/modules/lilv/serd-0.20.0/src/serdi.c

@@ -50,6 +50,7 @@ print_usage(const char* name, bool error)
 	fprintf(os, "  -f           Keep full URIs in input (don't qualify).\n");
 	fprintf(os, "  -h           Display this help and exit.\n");
 	fprintf(os, "  -i SYNTAX    Input syntax (`turtle' or `ntriples').\n");
+	fprintf(os, "  -l           Lax (non-strict) parsing.\n");
 	fprintf(os, "  -o SYNTAX    Output syntax (`turtle' or `ntriples').\n");
 	fprintf(os, "  -p PREFIX    Add PREFIX to blank node IDs.\n");
 	fprintf(os, "  -q           Suppress all output except data.\n");
@@ -100,6 +101,7 @@ main(int argc, char** argv)
 	bool           bulk_read     = true;
 	bool           bulk_write    = false;
 	bool           full_uris     = false;
+	bool           lax           = false;
 	bool           quiet         = false;
 	const uint8_t* in_name       = NULL;
 	const uint8_t* add_prefix    = NULL;
@@ -119,6 +121,8 @@ main(int argc, char** argv)
 			full_uris = true;
 		} else if (argv[a][1] == 'h') {
 			return print_usage(argv[0], false);
+		} else if (argv[a][1] == 'l') {
+			lax = true;
 		} else if (argv[a][1] == 'q') {
 			quiet = true;
 		} else if (argv[a][1] == 'v') {
@@ -215,6 +219,7 @@ main(int argc, char** argv)
 		(SerdStatementSink)serd_writer_write_statement,
 		(SerdEndSink)serd_writer_end_anon);
 
+	serd_reader_set_strict(reader, !lax);
 	if (quiet) {
 		serd_reader_set_error_sink(reader, quiet_error_sink, NULL);
 		serd_writer_set_error_sink(writer, quiet_error_sink, NULL);

source/modules/lilv/serd-0.20.0/src/writer.c

@@ -434,6 +434,14 @@ typedef enum {
 	FIELD_OBJECT
 } Field;
 
+static bool
+is_inline_start(const SerdWriter* writer, Field field, SerdStatementFlags flags)
+{
+	return (writer->syntax != SERD_NTRIPLES &&
+	        ((field == FIELD_SUBJECT && (flags & SERD_ANON_S_BEGIN)) ||
+	         (field == FIELD_OBJECT &&  (flags & SERD_ANON_O_BEGIN))));
+}
+
 static bool
 write_node(SerdWriter*        writer,
            const SerdNode*    node,
@@ -443,13 +451,12 @@ write_node(SerdWriter*        writer,
            SerdStatementFlags flags)
 {
 	SerdChunk uri_prefix;
-	SerdChunk uri_suffix;
+	SerdNode  prefix;
+	SerdChunk suffix;
 	bool      has_scheme;
 	switch (node->type) {
 	case SERD_BLANK:
-		if (writer->syntax != SERD_NTRIPLES
-		    && ((field == FIELD_SUBJECT && (flags & SERD_ANON_S_BEGIN))
-		        || (field == FIELD_OBJECT && (flags & SERD_ANON_O_BEGIN)))) {
+		if (is_inline_start(writer, field, flags)) {
 			++writer->indent;
 			write_sep(writer, SEP_ANON_BEGIN);
 		} else if (writer->syntax != SERD_NTRIPLES
@@ -484,18 +491,27 @@ write_node(SerdWriter*        writer,
 	case SERD_CURIE:
 		switch (writer->syntax) {
 		case SERD_NTRIPLES:
-			if (serd_env_expand(writer->env, node, &uri_prefix, &uri_suffix)) {
+			if (serd_env_expand(writer->env, node, &uri_prefix, &suffix)) {
 				w_err(writer, SERD_ERR_BAD_CURIE,
 				      "undefined namespace prefix `%s'\n", node->buf);
 				return false;
 			}
 			sink("<", 1, writer);
 			write_uri(writer, uri_prefix.buf, uri_prefix.len);
-			write_uri(writer, uri_suffix.buf, uri_suffix.len);
+			write_uri(writer, suffix.buf, suffix.len);
 			sink(">", 1, writer);
 			break;
 		case SERD_TURTLE:
+			if (is_inline_start(writer, field, flags)) {
+				++writer->indent;
+				write_sep(writer, SEP_ANON_BEGIN);
+				sink("== ", 3, writer);
+			}
 			write_lname(writer, node->buf, node->n_bytes);
+			if (is_inline_start(writer, field, flags)) {
+				sink(" ;", 2, writer);
+				write_newline(writer);
+			}
 		}
 		break;
 	case SERD_LITERAL:
@@ -536,6 +552,11 @@ write_node(SerdWriter*        writer,
 		}
 		break;
 	case SERD_URI:
+		if (is_inline_start(writer, field, flags)) {
+			++writer->indent;
+			write_sep(writer, SEP_ANON_BEGIN);
+			sink("== ", 3, writer);
+		}
 		has_scheme = serd_uri_string_has_scheme(node->buf);
 		if (field == FIELD_PREDICATE && (writer->syntax == SERD_TURTLE)
 		    && !strcmp((const char*)node->buf, NS_RDF "type")) {
@@ -545,15 +566,12 @@ write_node(SerdWriter*        writer,
 		           && !strcmp((const char*)node->buf, NS_RDF "nil")) {
 			sink("()", 2, writer);
 			break;
-		} else if (has_scheme && (writer->style & SERD_STYLE_CURIED)) {
-			SerdNode  prefix;
-			SerdChunk suffix;
-			if (serd_env_qualify(writer->env, node, &prefix, &suffix)) {
-				write_uri(writer, prefix.buf, prefix.n_bytes);
-				sink(":", 1, writer);
-				write_uri(writer, suffix.buf, suffix.len);
-				break;
-			}
+		} else if (has_scheme && (writer->style & SERD_STYLE_CURIED) &&
+		           serd_env_qualify(writer->env, node, &prefix, &suffix)) {
+			write_uri(writer, prefix.buf, prefix.n_bytes);
+			sink(":", 1, writer);
+			write_uri(writer, suffix.buf, suffix.len);
+			break;
 		}
 		sink("<", 1, writer);
 		if (writer->style & SERD_STYLE_RESOLVED) {
@@ -574,6 +592,10 @@ write_node(SerdWriter*        writer,
 			write_uri(writer, node->buf, node->n_bytes);
 		}
 		sink(">", 1, writer);
+		if (is_inline_start(writer, field, flags)) {
+			sink(" ;", 2, writer);
+			write_newline(writer);
+		}
 	default:
 		break;
 	}

source/modules/lilv/serd-0.20.0/tests/serd_test.c

@@ -45,7 +45,7 @@ static bool
 test_strtod(double dbl, double max_delta)
 {
 	char buf[1024];
-	snprintf(buf, sizeof(buf), "%lf", dbl);
+	snprintf(buf, sizeof(buf), "%f", dbl);
 
 	char* endptr = NULL;
 	const double out = serd_strtod(buf, &endptr);

source/modules/lilv/serd-0.20.0/wscript

@@ -11,7 +11,7 @@ import waflib.extras.autowaf as autowaf
 # major increment <=> incompatible changes
 # minor increment <=> compatible changes (additions)
 # micro increment <=> no interface changes
-SERD_VERSION       = '0.20.0'
+SERD_VERSION       = '0.21.1'
 SERD_MAJOR_VERSION = '0'
 
 # Mandatory waf variables
@@ -67,12 +67,6 @@ def configure(conf):
                    define_name = 'HAVE_GCOV',
                    mandatory   = False)
 
-    conf.check(function_name = 'fmax',
-               header_name   = 'math.h',
-               define_name   = 'HAVE_FMAX',
-               lib           = ['m'],
-               mandatory     = False)
-
     if not Options.options.no_posix:
         conf.check(function_name = 'posix_memalign',
                    header_name   = 'stdlib.h',
@@ -96,8 +90,8 @@ def configure(conf):
     autowaf.set_lib_env(conf, 'serd', SERD_VERSION)
     conf.write_config_header('serd_config.h', remove=False)
 
-    autowaf.display_msg(conf, 'Utilities', str(conf.env.BUILD_UTILS))
-    autowaf.display_msg(conf, 'Unit tests', str(conf.env.BUILD_TESTS))
+    autowaf.display_msg(conf, 'Utilities', bool(conf.env.BUILD_UTILS))
+    autowaf.display_msg(conf, 'Unit tests', bool(conf.env.BUILD_TESTS))
     print('')
 
 lib_source = [
@@ -214,7 +208,6 @@ def build(bld):
     # Man page
     bld.install_files('${MANDIR}/man1', 'doc/serdi.1')
 
-    bld.add_post_fun(autowaf.run_ldconfig)
     if bld.env.DOCS:
         bld.add_post_fun(fix_docs)