diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/serd_validate.c | 986 |
1 files changed, 986 insertions, 0 deletions
diff --git a/src/serd_validate.c b/src/serd_validate.c new file mode 100644 index 00000000..b852a3fa --- /dev/null +++ b/src/serd_validate.c @@ -0,0 +1,986 @@ +/* + Copyright 2012-2018 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. +*/ + +#define _BSD_SOURCE 1 // for realpath +#define _DEFAULT_SOURCE 1 // for realpath + +#include "serd_config.h" + +#include "serd/serd.h" + +#include <assert.h> +#include <limits.h> +#include <stdlib.h> +#include <string.h> + +#ifdef _WIN32 +#include <windows.h> +#endif + +#ifdef HAVE_PCRE +#include <pcre.h> +#endif + +#define NS_foaf "http://xmlns.com/foaf/0.1/" +#define NS_owl "http://www.w3.org/2002/07/owl#" +#define NS_rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#" +#define NS_rdfs "http://www.w3.org/2000/01/rdf-schema#" +#define NS_xsd "http://www.w3.org/2001/XMLSchema#" + +#define CERRORF(fmt, ...) fprintf(stderr, "serd_validate: " fmt, __VA_ARGS__); + +#define VERRORF(statement, fmt, ...) \ + report(statement, "error", fmt, __VA_ARGS__); + +#define VERROR(statement, fmt) report(statement, "error", fmt); + +#define VNOTEF(statement, fmt, ...) report(statement, "note", fmt, __VA_ARGS__); + +#define VNOTE(statement, fmt) report(statement, "note", fmt); + +#define SERD_FOREACH(name, range) \ + for (const SerdStatement* name = NULL; \ + !serd_range_empty(range) && (name = serd_range_front(range)); \ + serd_range_next(range)) + +typedef struct +{ + SerdNode* foaf_Document; + SerdNode* owl_Class; + SerdNode* owl_DatatypeProperty; + SerdNode* owl_FunctionalProperty; + SerdNode* owl_InverseFunctionalProperty; + SerdNode* owl_ObjectProperty; + SerdNode* owl_Restriction; + SerdNode* owl_Thing; + SerdNode* owl_allValuesFrom; + SerdNode* owl_cardinality; + SerdNode* owl_equivalentClass; + SerdNode* owl_maxCardinality; + SerdNode* owl_minCardinality; + SerdNode* owl_onDatatype; + SerdNode* owl_onProperty; + SerdNode* owl_someValuesFrom; + SerdNode* owl_withRestrictions; + SerdNode* rdf_PlainLiteral; + SerdNode* rdf_Property; + SerdNode* rdf_first; + SerdNode* rdf_rest; + SerdNode* rdf_type; + SerdNode* rdfs_Class; + SerdNode* rdfs_Datatype; + SerdNode* rdfs_Literal; + SerdNode* rdfs_Resource; + SerdNode* rdfs_domain; + SerdNode* rdfs_label; + SerdNode* rdfs_range; + SerdNode* rdfs_subClassOf; + SerdNode* xsd_anyURI; + SerdNode* xsd_float; + SerdNode* xsd_decimal; + SerdNode* xsd_double; + SerdNode* xsd_maxExclusive; + SerdNode* xsd_maxInclusive; + SerdNode* xsd_minExclusive; + SerdNode* xsd_minInclusive; + SerdNode* xsd_pattern; + SerdNode* xsd_string; +} URIs; + +static int n_errors = 0; +static int n_restrictions = 0; + +static int +check_class_restriction(SerdModel* model, + const URIs* uris, + const SerdNode* restriction, + const SerdStatement* statement, + const SerdNode* instance); + +static int +print_version(void) +{ + printf("serd_validate " SERD_VERSION + " <http://drobilla.net/software/serd>\n"); + printf("Copyright 2012-2018 David Robillard <http://drobilla.net>.\n" + "License: <http://www.opensource.org/licenses/isc>\n" + "This is free software; you are free to change and redistribute it." + "\nThere is NO WARRANTY, to the extent permitted by law.\n"); + return 0; +} + +static int +print_usage(const char* name, bool error) +{ + FILE* const os = error ? stderr : stdout; + fprintf(os, "Usage: %s [OPTION]... INPUT...\n", name); + fprintf(os, "Validate RDF data\n\n"); + fprintf(os, " -h Display this help and exit\n"); + fprintf(os, " -l Print errors on a single line.\n"); + fprintf(os, " -v Display version information and exit\n"); + fprintf(os, + "Validate RDF data. This is a simple validator which checks\n" + "that all used properties are actually defined. It does not do\n" + "any fancy file retrieval, the files passed on the command line\n" + "are the only data that is read. In other words, you must pass\n" + "the definition of all vocabularies used on the command line.\n"); + return error ? 1 : 0; +} + +static char* +absolute_path(const char* path) +{ +#ifdef _WIN32 + char* out = (char*)malloc(MAX_PATH); + GetFullPathName(path, MAX_PATH, out, NULL); + return out; +#else + return realpath(path, NULL); +#endif +} + +static int +report(const SerdStatement* statement, const char* type, const char* fmt, ...) +{ + va_list args; + va_start(args, fmt); + + fprintf(stderr, "%s: ", type); + + const SerdCursor* cursor = serd_statement_get_cursor(statement); + if (cursor) { + fprintf(stderr, + "%s:%u:%u: ", + serd_node_get_string(serd_cursor_get_name(cursor)), + serd_cursor_get_line(cursor), + serd_cursor_get_column(cursor)); + } + + vfprintf(stderr, fmt, args); + va_end(args); + + ++n_errors; + return 1; +} + +static bool +check(const bool value) +{ + ++n_restrictions; + return value; +} + +/** Return true iff `child` is a descendant of `parent` by `pred` arcs. + * + * This is, returns true if there is a path from `child` to `parent` by + * following `pred` arcs starting from child. + */ +static bool +is_descendant(SerdModel* model, + const URIs* uris, + const SerdNode* child, + const SerdNode* parent, + const SerdNode* pred) +{ + if (serd_node_equals(child, parent) || + serd_model_ask(model, child, uris->owl_equivalentClass, parent, NULL)) { + return true; + } + + SerdRange* i = serd_model_range(model, child, pred, NULL, NULL); + SERD_FOREACH (s, i) { + const SerdNode* o = serd_statement_get_object(s); + if (serd_node_equals(child, o)) { + continue; // Weird class is explicitly a descendent of itself + } + if (is_descendant(model, uris, o, parent, pred)) { + serd_range_free(i); + return true; + } + } + serd_range_free(i); + + return false; +} + +/** Return true iff `child` is a subclass of `parent`. */ +static bool +is_subclass(SerdModel* model, + const URIs* uris, + const SerdNode* child, + const SerdNode* parent) +{ + return is_descendant(model, uris, child, parent, uris->rdfs_subClassOf); +} + +/** Return true iff `child` is a sub-datatype of `parent`. */ +static bool +is_subdatatype(SerdModel* model, + const URIs* uris, + const SerdNode* child, + const SerdNode* parent) +{ + return is_descendant(model, uris, child, parent, uris->owl_onDatatype); +} + +static bool +regexp_match(const SerdStatement* pat_statement, const char* pat, const char* str) +{ +#ifdef HAVE_PCRE + // Append a $ to the pattern so we only match if the entire string matches + const size_t len = strlen(pat); + char* const regx = (char*)malloc(len + 2); + memcpy(regx, pat, len); + regx[len] = '$'; + regx[len + 1] = '\0'; + + const char* err; + int erroffset; + pcre* re = pcre_compile(regx, PCRE_ANCHORED, &err, &erroffset, NULL); + free(regx); + if (!re) { + VERRORF(pat_statement, + "Error in pattern \"%s\" at offset %d (%s)\n", + pat, + erroffset, + err); + return false; + } + + const bool ret = pcre_exec(re, NULL, str, strlen(str), 0, 0, NULL, 0) >= 0; + pcre_free(re); + return ret; +#endif // HAVE_PCRE + return true; +} + +static int +bound_cmp(SerdModel* model, + const URIs* uris, + const SerdNode* literal, + const SerdNode* type, + const SerdNode* bound) +{ + const char* str = serd_node_get_string(literal); + const char* bound_str = serd_node_get_string(bound); + const bool is_numeric = + is_subdatatype(model, uris, type, uris->xsd_decimal) || + is_subdatatype(model, uris, type, uris->xsd_double); + + if (is_numeric) { + const double fbound = serd_strtod(bound_str, NULL); + const double fliteral = serd_strtod(str, NULL); + return ((fliteral < fbound) ? -1 : (fliteral > fbound) ? 1 : 0); + } else { + return strcmp(str, bound_str); + } +} + +static bool +check_literal_restriction(SerdModel* model, + const URIs* uris, + const SerdStatement* statement, + const SerdNode* literal, + const SerdNode* type, + const SerdNode* restriction) +{ + const char* str = serd_node_get_string(literal); + + // Check xsd:pattern + const SerdStatement* pat_statement = serd_model_get_statement( + model, restriction, uris->xsd_pattern, 0, 0); + if (pat_statement) { + const SerdNode* pat_node = serd_statement_get_object(pat_statement); + const char* pat = serd_node_get_string(pat_node); + if (check(!regexp_match(pat_statement, pat, str))) { + VERRORF(statement, + "Value \"%s\" does not match pattern \"%s\"\n", + serd_node_get_string(literal), + pat); + return false; + } + } + + // Check xsd:minInclusive + const SerdNode* lower = + serd_model_get(model, restriction, uris->xsd_minInclusive, 0, 0); + if (lower) { + if (check(bound_cmp(model, uris, literal, type, lower) < 0)) { + VERRORF(statement, + "Value \"%s\" < minimum \"%s\"\n", + serd_node_get_string(literal), + serd_node_get_string(lower)); + return false; + } + } + + // Check xsd:maxInclusive + const SerdNode* upper = + serd_model_get(model, restriction, uris->xsd_maxInclusive, 0, 0); + if (upper) { + if (check(bound_cmp(model, uris, literal, type, upper) > 0)) { + VERRORF(statement, + "Value \"%s\" > than maximum \"%s\"\n", + serd_node_get_string(literal), + serd_node_get_string(upper)); + return false; + } + } + + // Check xsd:minExclusive + const SerdNode* elower = + serd_model_get(model, restriction, uris->xsd_minExclusive, 0, 0); + if (elower) { + if (check(bound_cmp(model, uris, literal, type, elower) <= 0)) { + VERRORF(statement, + "Value \"%s\" <= exclusive minimum \"%s\"\n", + serd_node_get_string(literal), + serd_node_get_string(elower)); + return false; + } + } + + // Check xsd:maxExclusive + const SerdNode* eupper = + serd_model_get(model, restriction, uris->xsd_maxExclusive, 0, 0); + if (eupper) { + if (check(bound_cmp(model, uris, literal, type, eupper) >= 0)) { + VERRORF(statement, + "Value \"%s\" >= exclusive maximum \"%s\"\n", + serd_node_get_string(literal), + serd_node_get_string(eupper)); + return false; + } + ++n_restrictions; + } + + return true; // Unknown restriction, be quietly tolerant +} + +static bool +is_datatype(SerdModel* model, const URIs* uris, const SerdNode* dtype) +{ + SerdRange* t = serd_model_range(model, dtype, uris->rdf_type, NULL, NULL); + SERD_FOREACH (s, t) { + const SerdNode* type = serd_statement_get_object(s); + if (is_subdatatype(model, uris, type, uris->rdfs_Datatype)) { + return true; // Subdatatype of rdfs:Datatype + } + } + + return false; +} + +static bool +literal_is_valid(SerdModel* model, + const URIs* uris, + const SerdStatement* statement, + const SerdNode* literal, + const SerdNode* type) +{ + if (!type) { + return true; + } + + // Check that datatype is defined + const SerdNode* datatype = serd_node_get_datatype(literal); + if (datatype && !is_datatype(model, uris, datatype)) { + VERRORF(statement, + "Datatype <%s> is not defined\n", + serd_node_get_string(datatype)); + return false; + } + + // Find restrictions list + const SerdNode* head = + serd_model_get(model, type, uris->owl_withRestrictions, 0, 0); + + // Walk list, checking each restriction + while (head) { + SerdIter* f = serd_model_find(model, head, uris->rdf_first, 0, 0); + if (!f) { + break; + } + + const SerdNode* first = serd_statement_get_object(serd_iter_get(f)); + + // Check this restriction + if (!check_literal_restriction( + model, uris, statement, literal, type, first)) { + VNOTEF(serd_iter_get(f), + "Restriction on <%s>\n", + serd_node_get_string(type)); + return false; + } + + // Seek to next list node + head = serd_model_get(model, head, uris->rdf_rest, 0, 0); + } + + // Recurse up datatype hierarchy + const SerdNode* super = + serd_model_get(model, type, uris->owl_onDatatype, 0, 0); + return super ? literal_is_valid(model, uris, statement, literal, super) + : true; +} + +static bool +has_explicit_type(SerdModel* model, + const URIs* uris, + const SerdNode* node, + const SerdNode* klass) +{ + if (serd_model_ask(model, node, uris->rdf_type, klass, NULL)) { + return true; // Directly stated to be an instance + } + + SerdRange* t = serd_model_range(model, node, uris->rdf_type, NULL, NULL); + SERD_FOREACH (s, t) { + if (is_subclass(model, uris, serd_statement_get_object(s), klass)) { + return true; // Explicit instance of a subclass + } + } + + return false; +} + +static bool +is_instance_of(SerdModel* model, + const URIs* uris, + const SerdStatement* statement, + const SerdNode* node, + const SerdNode* klass) +{ + if (!serd_model_ask(model, node, NULL, NULL, NULL)) { + /* Nothing about this node known in the model at all, assume it is some + external resource we can't validate. */ + return true; + } else if (serd_node_get_type(node) == SERD_BLANK) { + /* Be permissive for blank nodes and don't require explicit type + annotation, to avoid countless errors with things like lists. */ + return true; + } + + return (has_explicit_type(model, uris, node, klass) || + serd_node_equals(klass, uris->rdfs_Resource) || + serd_node_equals(klass, uris->owl_Thing)); +} + +static bool +check_instance_type(SerdModel* model, + const URIs* uris, + const SerdStatement* statement, + const SerdNode* node, + const SerdNode* klass) +{ + if (is_subclass(model, uris, klass, uris->rdfs_Literal) || + serd_model_ask(model, klass, uris->rdf_type, uris->rdfs_Datatype, 0)) { + VERROR(statement, "Class instance found where literal expected\n"); + return false; + } + + if (serd_model_ask( + model, klass, uris->rdf_type, uris->owl_Restriction, NULL)) { + if (check_class_restriction(model, uris, klass, statement, node)) { + return false; + } + } + + SerdRange* r = + serd_model_range(model, klass, uris->rdfs_subClassOf, NULL, NULL); + SERD_FOREACH (s, r) { + const SerdNode* super = serd_statement_get_object(s); + if (!serd_node_equals(super, klass)) { + if (!check_instance_type(model, uris, statement, node, super)) { + return false; + } + } + } + + if (!is_instance_of(model, uris, statement, node, klass)) { + VERRORF(statement, + "Node %s is not an instance of %s\n", + serd_node_get_string(node), + serd_node_get_string(klass)); + return false; + } + + return true; // FIXME? +} + +static bool +check_type(SerdModel* model, + const URIs* uris, + const SerdStatement* statement, + const SerdNode* node, + const SerdNode* type) +{ + if (serd_node_equals(type, uris->rdfs_Resource) || + serd_node_equals(type, uris->owl_Thing)) { + return true; // Trivially true for everything (more or less) + } + + if (serd_node_get_type(node) == SERD_LITERAL) { + if (serd_node_equals(type, uris->rdfs_Literal)) { + return true; // Trivially true for a literal + } else if (serd_node_equals(type, uris->rdf_PlainLiteral)) { + if (serd_node_get_datatype(node)) { + VERRORF(statement, + "Literal \"%s\" should be plain, but has datatype " + "<%s>\n", + serd_node_get_string(node), + serd_node_get_string(serd_node_get_datatype(node))); + return false; + } + return true; + } else if (!serd_model_ask(model, + type, + uris->rdf_type, + uris->rdfs_Datatype, + NULL)) { + VERRORF(statement, + "Literal \"%s\" where instance of <%s> expected\n", + serd_node_get_string(node), + serd_node_get_string(type)); + return false; + } else { + return literal_is_valid(model, uris, statement, node, type); + } + } else if (serd_node_get_type(node) == SERD_URI) { + if (is_subdatatype(model, uris, type, uris->xsd_anyURI)) { + /* Type is any URI and this is a URI, so pass. Restrictions on + anyURI subtypes are not currently checked (very uncommon). */ + return true; + } else { + return check_instance_type(model, uris, statement, node, type); + } + } else { + return check_instance_type(model, uris, statement, node, type); + } + + VERRORF(statement, + "Unhandled case checking if %s is of type %s\n", + serd_node_get_string(node), + serd_node_get_string(type)); + + return false; +} + +static uint64_t +count_non_blanks(SerdRange* i, SerdField field) +{ + uint64_t n = 0; + SERD_FOREACH (s, i) { + const SerdNode* node = serd_statement_get_node(s, field); + if (serd_node_get_type(node) != SERD_BLANK) { + ++n; + } + } + return n; +} + +static int +check_statement(SerdModel* model, + const URIs* uris, + const SerdStatement* statement) +{ + int st = 0; + + const SerdNode* subj = serd_statement_get_subject(statement); + const SerdNode* pred = serd_statement_get_predicate(statement); + const SerdNode* obj = serd_statement_get_object(statement); + + // Check that predicate is defined as some kind of propety + bool is_property = false; + SerdRange* t = serd_model_range(model, pred, uris->rdf_type, NULL, NULL); + SERD_FOREACH (s, t) { + const SerdNode* type = serd_statement_get_object(s); + if (is_subclass(model, uris, type, uris->rdf_Property)) { + is_property = true; + break; + } + } + serd_range_free(t); + + if (!is_property) { + st = VERROR(statement, "Use of undefined property\n"); + } + + if (serd_node_equals(pred, uris->rdf_type)) { + // Type statement, check that object is a valid instance of type + check_type(model, uris, statement, subj, obj); + } + + const bool is_ObjectProperty = serd_model_ask( + model, pred, uris->rdf_type, uris->owl_ObjectProperty, 0); + const bool is_FunctionalProperty = serd_model_ask( + model, pred, uris->rdf_type, uris->owl_FunctionalProperty, 0); + const bool is_InverseFunctionalProperty = + serd_model_ask(model, + pred, + uris->rdf_type, + uris->owl_InverseFunctionalProperty, + 0); + const bool is_DatatypeProperty = serd_model_ask( + model, pred, uris->rdf_type, uris->owl_DatatypeProperty, 0); + + if (!serd_model_ask(model, pred, uris->rdfs_label, NULL, NULL)) { + st = VERRORF(statement, + "Property <%s> has no label\n", + serd_node_get_string(pred)); + } + + if (is_DatatypeProperty && serd_node_get_type(obj) != SERD_LITERAL) { + st = VERROR(statement, "Datatype property with non-literal value\n"); + } + + if (is_ObjectProperty && serd_node_get_type(obj) == SERD_LITERAL) { + st = VERROR(statement, "Object property with literal value\n"); + } + + if (is_FunctionalProperty) { + SerdRange* o = serd_model_range(model, subj, pred, NULL, NULL); + const uint64_t n = count_non_blanks(o, SERD_OBJECT); + if (n > 1) { + st = VERRORF(statement, "Functional property with %u objects\n", n); + } + serd_range_free(o); + } + + if (is_InverseFunctionalProperty) { + SerdRange* s = serd_model_range(model, NULL, pred, obj, NULL); + const unsigned n = count_non_blanks(s, SERD_SUBJECT); + if (n > 1) { + st = VERRORF(statement, + "Inverse functional property with %u subjects\n", + n); + } + serd_range_free(s); + } + + if (serd_node_get_type(obj) == SERD_LITERAL && + !literal_is_valid( + model, uris, statement, obj, serd_node_get_datatype(obj))) { + /* st = VERRORF(statement, "Literal does not match datatype\n"); */ + } + + // Check range + SerdRange* r = serd_model_range(model, pred, uris->rdfs_range, NULL, NULL); + SERD_FOREACH (s, r) { + const SerdNode* range = serd_statement_get_object(s); + if (has_explicit_type(model, uris, obj, range)) { + continue; // Explicit type will be checked, avoid duplicate reports + } + + if (!check_type(model, uris, statement, obj, range)) { + VNOTEF(serd_range_front(r), + "Range of <%s> defined here\n", + serd_node_get_string(pred)); + } + } + serd_range_free(r); + + // Check domain + SerdRange* d = serd_model_range(model, pred, uris->rdfs_domain, NULL, NULL); + SERD_FOREACH (s, d) { + const SerdNode* domain = serd_statement_get_object(s); + if (has_explicit_type(model, uris, subj, domain)) { + continue; // Explicit type will be checked, avoid duplicate reports + } + + if (!check_type(model, uris, statement, subj, domain)) { + VNOTEF(serd_range_front(d), + "Domain of <%s> defined here\n", + serd_node_get_string(pred)); + } + } + serd_range_free(d); + + return st; +} + +static int +check_properties(SerdModel* model, URIs* uris) +{ + int st = 0; + SerdRange* i = serd_model_range(model, NULL, NULL, NULL, NULL); + SERD_FOREACH (statement, i) { + st = check_statement(model, uris, statement) || st; + } + serd_range_free(i); + + return st; +} + +static int +cardinality_error(const SerdStatement* statement, + const SerdStatement* restriction_statement, + const SerdNode* property, + const SerdNode* instance, + const unsigned actual_values, + const char* comparison, + const unsigned expected_values) +{ + const int st = VERRORF(statement, + "Property <%s> has %u %s %u values\n", + serd_node_get_string(property), + actual_values, + comparison, + expected_values); + VNOTE(restriction_statement, "Restriction here\n"); + return st; +} + +static int +check_class_restriction(SerdModel* model, + const URIs* uris, + const SerdNode* restriction, + const SerdStatement* statement, + const SerdNode* instance) +{ + int st = 0; + const SerdNode* prop = serd_model_get( + model, restriction, uris->owl_onProperty, NULL, NULL); + if (!prop) { + return 0; + } + + const unsigned values = serd_model_count(model, instance, prop, NULL, NULL); + + // Check exact cardinality + const SerdStatement* c = serd_model_get_statement( + model, restriction, uris->owl_cardinality, NULL, NULL); + if (c) { + const SerdNode* card = serd_statement_get_object(c); + const unsigned count = atoi(serd_node_get_string(card)); + if (check(values != count)) { + st = cardinality_error( + statement, c, prop, instance, values, "!=", count); + } + } + + // Check minimum cardinality + const SerdStatement* l = serd_model_get_statement( + model, restriction, uris->owl_minCardinality, NULL, NULL); + if (l) { + const SerdNode* card = serd_statement_get_object(l); + const unsigned count = atoi(serd_node_get_string(card)); + if (check(values < count)) { + st = cardinality_error( + statement, l, prop, instance, values, "<", count); + } + } + + // Check maximum cardinality + const SerdStatement* u = serd_model_get_statement( + model, restriction, uris->owl_maxCardinality, NULL, NULL); + if (u) { + const SerdNode* card = serd_statement_get_object(u); + const unsigned count = atoi(serd_node_get_string(card)); + if (check(values > count)) { + st = cardinality_error( + statement, u, prop, instance, values, ">", count); + } + } + + // Check someValuesFrom + const SerdStatement* s = serd_model_get_statement( + model, restriction, uris->owl_someValuesFrom, 0, 0); + if (s) { + const SerdNode* some = serd_statement_get_object(s); + + SerdRange* v = serd_model_range(model, instance, prop, NULL, NULL); + bool found = false; + SERD_FOREACH (i, v) { + const SerdNode* value = serd_statement_get_object(i); + if (check_type(model, uris, statement, value, some)) { + found = true; + break; + } + } + if (check(!found)) { + st = VERRORF(statement, + "%s has no <%s> values of type <%s>\n", + serd_node_get_string(instance), + serd_node_get_string(prop), + serd_node_get_string(some)); + VNOTE(s, "Restriction here\n"); + } + serd_range_free(v); + } + + // Check allValuesFrom + const SerdStatement* a = serd_model_get_statement( + model, restriction, uris->owl_allValuesFrom, 0, 0); + if (a) { + ++n_restrictions; + const SerdNode* all = serd_statement_get_object(a); + + SerdRange* v = serd_model_range(model, instance, prop, NULL, NULL); + SERD_FOREACH (i, v) { + const SerdNode* value = serd_statement_get_object(i); + if (!check_type(model, uris, statement, value, all)) { + st = VERRORF(i, + "<%s> value not of type <%s>\n", + serd_node_get_string(prop), + serd_node_get_string(all)); + VNOTE(a, "Restriction here\n"); + break; + } + } + serd_range_free(v); + } + + return st; +} + +static int +missing_arg(const char* name, char opt) +{ + CERRORF("option requires an argument -- '%c'\n", opt); + return print_usage(name, true); +} + +static void +init_uris(URIs* uris) +{ +#define URI(prefix, suffix) \ + uris->prefix##_##suffix = serd_new_uri(NS_##prefix #suffix) + + URI(foaf, Document); + URI(owl, Class); + URI(owl, DatatypeProperty); + URI(owl, FunctionalProperty); + URI(owl, InverseFunctionalProperty); + URI(owl, ObjectProperty); + URI(owl, Restriction); + URI(owl, Thing); + URI(owl, allValuesFrom); + URI(owl, cardinality); + URI(owl, equivalentClass); + URI(owl, maxCardinality); + URI(owl, minCardinality); + URI(owl, onDatatype); + URI(owl, onProperty); + URI(owl, someValuesFrom); + URI(owl, withRestrictions); + URI(rdf, PlainLiteral); + URI(rdf, Property); + URI(rdf, first); + URI(rdf, rest); + URI(rdf, type); + URI(rdfs, Class); + URI(rdfs, Datatype); + URI(rdfs, Literal); + URI(rdfs, Resource); + URI(rdfs, domain); + URI(rdfs, label); + URI(rdfs, range); + URI(rdfs, subClassOf); + URI(xsd, anyURI); + URI(xsd, float); + URI(xsd, decimal); + URI(xsd, double); + URI(xsd, maxExclusive); + URI(xsd, maxInclusive); + URI(xsd, minExclusive); + URI(xsd, minInclusive); + URI(xsd, pattern); + URI(xsd, string); +} + +int +main(int argc, char** argv) +{ + if (argc < 2) { + return print_usage(argv[0], true); + } + + int a = 1; + long stack_size = 4194304; + for (; a < argc && argv[a][0] == '-'; ++a) { + if (argv[a][1] == 'h') { + return print_usage(argv[0], false); + } else if (argv[a][1] == 'k') { + if (++a == argc) { + return missing_arg(argv[0], 'k'); + } + stack_size = strtol(argv[a], NULL, 10); + if (stack_size <= 0 || stack_size == LONG_MAX) { + CERRORF("stack size `%ld' out of range\n", stack_size); + return 1; + } + } else if (argv[a][1] == 'v') { + return print_version(); + } else { + CERRORF("invalid option -- '%s'\n", argv[a] + 1); + return print_usage(argv[0], true); + } + } + + SerdWorld* world = serd_world_new(); + SerdModel* model = serd_model_new(world, SERD_SPO | SERD_OPS, false); + SerdEnv* env = serd_env_new(NULL); + SerdInserter* inserter = serd_inserter_new(model, env, NULL); + SerdReader* reader = serd_reader_new( + world, SERD_TURTLE, serd_inserter_get_sink(inserter), stack_size); + + for (; a < argc; ++a) { + const char* input = argv[a]; + char* in_path = absolute_path(input); + + if (!in_path) { + CERRORF("unable to open file %s\n", input); + continue; + } + + SerdNode* base_uri_node = serd_new_file_uri(in_path, NULL); + + serd_env_set_base_uri(env, base_uri_node); + SerdStatus st = serd_reader_start_file(reader, input, true); + st = serd_reader_read_document(reader); + st = serd_reader_finish(reader); + + if (st) { + CERRORF("error reading %s: %s\n", in_path, serd_strerror(st)); + return 1; + } + + serd_node_free(base_uri_node); + free(in_path); + } + serd_reader_free(reader); + serd_env_free(env); + + URIs uris; + init_uris(&uris); + +#ifndef HAVE_PCRE + fprintf(stderr, "warning: Built without PCRE, datatypes not checked.\n"); +#endif + + const int st = check_properties(model, &uris); + + printf("Found %d errors among %d files (checked %d restrictions)\n", + n_errors, + argc - 1, + n_restrictions); + + serd_model_free(model); + serd_world_free(world); + + return !st && n_errors == 0 ? 0 : 2; +} |