diff --git a/source/carla_skin.py b/source/carla_skin.py index bf0633a29..40f1ef371 100755 --- a/source/carla_skin.py +++ b/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(): diff --git a/source/modules/lilv/serd-0.20.0/NEWS b/source/modules/lilv/serd-0.20.0/NEWS index 91d892946..84eb68ef1 100644 --- a/source/modules/lilv/serd-0.20.0/NEWS +++ b/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 Sat, 04 Apr 2015 16:22:17 -0400 + serd (0.20.0) stable; * Support new RDF 1.1 Turtle diff --git a/source/modules/lilv/serd-0.20.0/serd-0.20.0.tar.bz2.sig b/source/modules/lilv/serd-0.20.0/serd-0.20.0.tar.bz2.sig deleted file mode 100644 index bb1bbf584..000000000 Binary files a/source/modules/lilv/serd-0.20.0/serd-0.20.0.tar.bz2.sig and /dev/null differ diff --git a/source/modules/lilv/serd-0.20.0/serd.pc.in b/source/modules/lilv/serd-0.20.0/serd.pc.in index c3604c8ac..02e1b8b73 100644 --- a/source/modules/lilv/serd-0.20.0/serd.pc.in +++ b/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@ diff --git a/source/modules/lilv/serd-0.20.0/serd/serd.h b/source/modules/lilv/serd-0.20.0/serd/serd.h index b5703a203..75323e0d3 100644 --- a/source/modules/lilv/serd-0.20.0/serd/serd.h +++ b/source/modules/lilv/serd-0.20.0/serd/serd.h @@ -183,7 +183,7 @@ typedef enum { @see Turtle nodeID */ - 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. diff --git a/source/modules/lilv/serd-0.20.0/src/node.c b/source/modules/lilv/serd-0.20.0/src/node.c index 921b05de8..1f8cb115a 100644 --- a/source/modules/lilv/serd-0.20.0/src/node.c +++ b/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 }; diff --git a/source/modules/lilv/serd-0.20.0/src/reader.c b/source/modules/lilv/serd-0.20.0/src/reader.c index c911f1589..012dcb432 100644 --- a/source/modules/lilv/serd-0.20.0/src/reader.c +++ b/source/modules/lilv/serd-0.20.0/src/reader.c @@ -17,6 +17,7 @@ #include "serd_internal.h" #include +#include #include #include #include @@ -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; } diff --git a/source/modules/lilv/serd-0.20.0/src/serd_internal.h b/source/modules/lilv/serd-0.20.0/src/serd_internal.h index d96d49693..20700bb8c 100644 --- a/source/modules/lilv/serd-0.20.0/src/serd_internal.h +++ b/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* diff --git a/source/modules/lilv/serd-0.20.0/src/serdi.c b/source/modules/lilv/serd-0.20.0/src/serdi.c index 3543580ac..7568378d8 100644 --- a/source/modules/lilv/serd-0.20.0/src/serdi.c +++ b/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); diff --git a/source/modules/lilv/serd-0.20.0/src/writer.c b/source/modules/lilv/serd-0.20.0/src/writer.c index 1c59a3e7d..4eb394936 100644 --- a/source/modules/lilv/serd-0.20.0/src/writer.c +++ b/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; } diff --git a/source/modules/lilv/serd-0.20.0/tests/serd_test.c b/source/modules/lilv/serd-0.20.0/tests/serd_test.c index 971d6e01a..eecbb5b0b 100644 --- a/source/modules/lilv/serd-0.20.0/tests/serd_test.c +++ b/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); diff --git a/source/modules/lilv/serd-0.20.0/waf b/source/modules/lilv/serd-0.20.0/waf index a59c289c6..6bbcbee5d 100755 Binary files a/source/modules/lilv/serd-0.20.0/waf and b/source/modules/lilv/serd-0.20.0/waf differ diff --git a/source/modules/lilv/serd-0.20.0/wscript b/source/modules/lilv/serd-0.20.0/wscript index fb8df19fd..a8c9f443d 100644 --- a/source/modules/lilv/serd-0.20.0/wscript +++ b/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)