diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/serd_validate.c | 884 |
1 files changed, 884 insertions, 0 deletions
diff --git a/src/serd_validate.c b/src/serd_validate.c new file mode 100644 index 00000000..a190f99d --- /dev/null +++ b/src/serd_validate.c @@ -0,0 +1,884 @@ +/* + 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/serd.h" +#include "serd/serd.h" +#include "serd_config.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 USTR(s) ((const uint8_t*)(s)) + +#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 ERROR(msg) fprintf(stderr, "serd_validate: " msg); +#define ERRORF(fmt, ...) fprintf(stderr, "serd_validate: " fmt, __VA_ARGS__); + +#define SERD_FOREACH(name, iter) \ + for (const SerdStatement* name = NULL; \ + !serd_iter_end(iter) && (name = serd_iter_get(iter)); \ + serd_iter_next(iter)) + +typedef struct +{ + SerdNode* foaf_Document; + SerdNode* owl_AnnotationProperty; + SerdNode* owl_Class; + SerdNode* owl_DatatypeProperty; + SerdNode* owl_FunctionalProperty; + SerdNode* owl_InverseFunctionalProperty; + SerdNode* owl_ObjectProperty; + SerdNode* owl_OntologyProperty; + SerdNode* owl_Restriction; + SerdNode* owl_Thing; + 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_decimal; + SerdNode* xsd_double; + SerdNode* xsd_maxInclusive; + SerdNode* xsd_minInclusive; + SerdNode* xsd_pattern; + SerdNode* xsd_string; +} URIs; + +int n_errors = 0; +int n_restrictions = 0; +bool one_line_errors = false; + +static int +check_instance(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 +errorf(const SerdStatement* statement, const char* fmt, ...) +{ + va_list args; + va_start(args, fmt); + fprintf(stderr, "error: "); + vfprintf(stderr, fmt, args); + va_end(args); + + const char* sep = one_line_errors ? "\t" : "\n "; + fprintf(stderr, + "%s%s%s%s%s%s\n", + sep, + serd_node_get_string(serd_statement_get_subject(statement)), + sep, + serd_node_get_string(serd_statement_get_predicate(statement)), + sep, + serd_node_get_string(serd_statement_get_object(statement))); + + ++n_errors; + return 1; +} + +static bool +is_descendant_of(SerdModel* model, + const URIs* uris, + const SerdNode* child, + const SerdNode* parent, + const SerdNode* pred) +{ + if (!child) { + return false; + } else if (serd_node_equals(child, parent) || + serd_model_ask( + model, child, uris->owl_equivalentClass, parent, NULL)) { + return true; + } + + SerdIter* i = serd_model_find(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_of(model, uris, o, parent, pred)) { + serd_iter_free(i); + return true; + } + } + serd_iter_free(i); + + return false; +} + +static bool +regexp_match(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) { + fprintf(stderr, + "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 SerdNode* pred = uris->owl_onDatatype; + const bool is_numeric = + is_descendant_of(model, uris, type, uris->xsd_decimal, pred) || + is_descendant_of(model, uris, type, uris->xsd_double, pred); + + 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_restriction(SerdModel* model, + const URIs* uris, + const SerdNode* literal, + const SerdNode* type, + const SerdNode* restriction) +{ + const char* str = serd_node_get_string(literal); + + // Check xsd:pattern + const SerdNode* pat = + serd_model_get(model, restriction, uris->xsd_pattern, 0, 0); + if (pat) { + if (!regexp_match(serd_node_get_string(pat), str)) { + fprintf(stderr, + "`%s' does not match <%s> pattern `%s'\n", + serd_node_get_string(literal), + serd_node_get_string(type), + serd_node_get_string(pat)); + return false; + } + ++n_restrictions; + } + + // Check xsd:minInclusive + const SerdNode* lower = + serd_model_get(model, restriction, uris->xsd_minInclusive, 0, 0); + if (lower) { + if (bound_cmp(model, uris, literal, type, lower) < 0) { + fprintf(stderr, + "`%s' is not >= <%s> minimum `%s'\n", + serd_node_get_string(literal), + serd_node_get_string(type), + serd_node_get_string(lower)); + return false; + } + ++n_restrictions; + } + + // Check xsd:maxInclusive + const SerdNode* upper = + serd_model_get(model, restriction, uris->xsd_maxInclusive, 0, 0); + if (upper) { + if (bound_cmp(model, uris, literal, type, upper) > 0) { + fprintf(stderr, + "`%s' is not <= <%s> maximum `%s'\n", + serd_node_get_string(literal), + serd_node_get_string(type), + serd_node_get_string(upper)); + return false; + } + ++n_restrictions; + } + + return true; // Unknown restriction, be quietly tolerant +} + +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 literal data is related to required type. We don't do a + strict subtype check here because e.g. an xsd:decimal might be a valid + xsd:unsignedInt, which the pattern checks will verify, but if the + literal type is not related to the required type at all + (e.g. xsd:decimal and xsd:string) there is a problem. */ + const SerdNode* datatype = serd_node_get_datatype(literal); + if (datatype && datatype != type) { + if (!is_descendant_of( + model, uris, datatype, type, uris->owl_onDatatype) && + !is_descendant_of( + model, uris, type, datatype, uris->owl_onDatatype) && + !(serd_node_equals(datatype, uris->xsd_decimal) && + is_descendant_of(model, + uris, + type, + uris->xsd_double, + uris->owl_onDatatype))) { + errorf(statement, + "Literal `%s' datatype <%s> is not compatible with <%s>\n", + serd_node_get_string(literal), + serd_node_get_string(datatype), + serd_node_get_string(type)); + return false; + } + } + + // Find restrictions list + const SerdNode* head = + serd_model_get(model, type, uris->owl_withRestrictions, 0, 0); + if (!head) { + return true; // No restrictions + } + + // Walk list, checking each restriction + while (head) { + SerdIter* f = serd_model_find(model, head, uris->rdf_first, 0, 0); + if (!f) { + break; // Reached end of restrictions list without failure + } + + // Check this restriction + const bool good = + check_restriction(model, + uris, + literal, + type, + serd_statement_get_object(serd_iter_get(f))); + serd_iter_free(f); + + if (!good) { + return false; // Failed, literal is invalid + } + + // Seek to next list node + SerdIter* n = serd_model_find(model, head, uris->rdf_rest, 0, 0); + head = n ? serd_statement_get_object(serd_iter_get(n)) : NULL; + serd_iter_free(n); + } + + const SerdNode* super = + serd_model_get(model, type, uris->owl_onDatatype, 0, 0); + if (super) { + const bool good = + literal_is_valid(model, uris, statement, literal, super); + return good; // Match iff literal also matches supertype + } + + return true; // Matches top level type +} + +static bool +check_resource_type(SerdModel* model, + const URIs* uris, + const SerdStatement* statement, + const SerdNode* node, + const SerdNode* klass) +{ + if (serd_node_get_type(node) == SERD_LITERAL) { + errorf(statement, "Literal found where class instance expected"); + return false; + } else if (is_descendant_of(model, + uris, + klass, + uris->rdfs_Literal, + uris->rdfs_subClassOf) || + serd_model_ask( + model, klass, uris->rdf_type, uris->rdfs_Datatype, 0)) { + errorf(statement, "Resource found where literal expected"); + return false; + } + + if (serd_model_ask( + model, klass, uris->rdf_type, uris->owl_Restriction, NULL)) { + if (check_instance(model, uris, klass, statement, node)) { + return false; + } + } + + SerdIter* r = serd_model_find(model, klass, uris->rdfs_subClassOf, NULL, NULL); + SERD_FOREACH (s, r) { + const SerdNode* super = serd_statement_get_object(s); + if (!check_resource_type(model, uris, statement, node, super)) { + return false; + } + } + + return true; +} + +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; + } + + if (serd_node_get_type(node) == SERD_LITERAL) { + if (serd_node_equals(type, uris->rdfs_Literal)) { + return true; + } else if (serd_node_equals(type, uris->rdf_PlainLiteral)) { + return !serd_node_get_language(node); + } else { + return literal_is_valid(model, uris, statement, node, type); + } + } else if (serd_node_get_type(node) == SERD_URI) { + if (serd_node_equals(type, uris->foaf_Document)) { + return true; // Questionable... + } else if (is_descendant_of(model, + uris, + type, + uris->xsd_anyURI, + uris->owl_onDatatype)) { + /* Type is any URI and this is a URI, so pass. Restrictions on + anyURI subtypes are not currently checked (very uncommon). */ + return true; // Type is anyURI, and this is a URI + } else { + return check_resource_type(model, uris, statement, node, type); + } + } else { + if (!check_resource_type(model, uris, statement, node, type)) { + return false; + } + + return true; // Blanks often lack explicit types, ignore + } + + return false; +} + +static uint64_t +count_non_blanks(SerdIter* 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_properties(SerdModel* model, URIs* uris) +{ + int st = 0; + SerdIter* i = serd_model_begin(model); + SERD_FOREACH (statement, i) { + const SerdNode* subj = serd_statement_get_subject(statement); + const SerdNode* pred = serd_statement_get_predicate(statement); + const SerdNode* obj = serd_statement_get_object(statement); + + bool is_any_property = false; + SerdIter* t = serd_model_find(model, pred, uris->rdf_type, NULL, NULL); + SERD_FOREACH (s, t) { + if (is_descendant_of(model, + uris, + serd_statement_get_object(s), + uris->rdf_Property, + uris->rdfs_subClassOf)) { + is_any_property = true; + break; + } + } + serd_iter_free(t); + + 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 (!is_any_property) { + st = errorf(statement, "Use of undefined property"); + } + + if (!serd_model_ask(model, pred, uris->rdfs_label, NULL, NULL)) { + st = errorf(statement, + "Property <%s> has no label", + serd_node_get_string(pred)); + } + + if (is_DatatypeProperty && serd_node_get_type(obj) != SERD_LITERAL) { + st = errorf(statement, "Datatype property with non-literal value"); + } + + if (is_ObjectProperty && serd_node_get_type(obj) == SERD_LITERAL) { + st = errorf(statement, "Object property with literal value"); + } + + if (is_FunctionalProperty) { + SerdIter* o = serd_model_find(model, subj, pred, NULL, NULL); + const uint64_t n = count_non_blanks(o, SERD_OBJECT); + if (n > 1) { + st = errorf( + statement, "Functional property with %u objects", n); + } + serd_iter_free(o); + } + + if (is_InverseFunctionalProperty) { + SerdIter* s = serd_model_find(model, NULL, pred, obj, NULL); + const unsigned n = count_non_blanks(s, SERD_SUBJECT); + if (n > 1) { + st = errorf(statement, + "Inverse functional property with %u subjects", + n); + } + serd_iter_free(s); + } + + if (serd_node_equals(pred, uris->rdf_type) && + !serd_model_ask( + model, obj, uris->rdf_type, uris->rdfs_Class, NULL) && + !serd_model_ask( + model, obj, uris->rdf_type, uris->owl_Class, NULL)) { + st = errorf(statement, "Type is not a rdfs:Class or owl:Class"); + } + + if (serd_node_get_type(obj) == SERD_LITERAL && + !literal_is_valid( + model, uris, statement, obj, serd_node_get_datatype(obj))) { + st = errorf(statement, "Literal does not match datatype"); + } + + SerdIter* r = + serd_model_find(model, pred, uris->rdfs_range, NULL, NULL); + SERD_FOREACH (s, r) { + const SerdNode* range = serd_statement_get_object(s); + if (!check_type(model, uris, statement, obj, range)) { + st = errorf(statement, + "Object not in range <%s>", + serd_node_get_string(range)); + } + } + serd_iter_free(r); + + SerdIter* d = + serd_model_find(model, pred, uris->rdfs_domain, NULL, NULL); + if (d) { + const SerdNode* domain = + serd_statement_get_object(serd_iter_get(d)); + if (!check_type(model, uris, statement, subj, domain)) { + st = errorf(statement, + "Subject not in domain <%s>", + serd_node_get_string(domain)); + } + serd_iter_free(d); + } + } + serd_iter_free(i); + + return st; +} + +static int +check_instance(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 SerdNode* card = serd_model_get( + model, restriction, uris->owl_cardinality, NULL, NULL); + if (card) { + const unsigned c = atoi(serd_node_get_string(card)); + if (values != c) { + st = errorf(statement, + "Property %s on %s has %u != %u values", + serd_node_get_string(prop), + serd_node_get_string(instance), + values, + c); + } + } + + // Check minimum cardinality + const SerdNode* minCard = serd_model_get( + model, restriction, uris->owl_minCardinality, NULL, NULL); + if (minCard) { + const unsigned m = atoi(serd_node_get_string(minCard)); + if (values < m) { + st = errorf(statement, + "Property %s on %s has %u < %u values", + serd_node_get_string(prop), + serd_node_get_string(instance), + values, + m); + } + } + + // Check maximum cardinality + const SerdNode* maxCard = serd_model_get( + model, restriction, uris->owl_maxCardinality, NULL, NULL); + if (maxCard) { + const unsigned m = atoi(serd_node_get_string(maxCard)); + if (values < m) { + st = errorf(statement, + "Property %s on %s has %u > %u values", + serd_node_get_string(prop), + serd_node_get_string(instance), + values, + m); + } + } + + // Check someValuesFrom + const SerdNode* type = serd_model_get( + model, restriction, uris->owl_someValuesFrom, 0, 0); + if (type) { + SerdIter* v = serd_model_find(model, instance, prop, NULL, NULL); + bool found = false; + SERD_FOREACH (s, v) { + const SerdNode* value = serd_statement_get_object(s); + if (check_type(model, uris, statement, value, type)) { + found = true; + break; + } + } + if (!found) { + st = errorf(statement, + "%s has no <%s> values of type <%s>\n", + serd_node_get_string(instance), + serd_node_get_string(prop), + serd_node_get_string(type)); + } + serd_iter_free(v); + } + + return st; +} + +static int +check_class_instances(SerdModel* model, + const URIs* uris, + const SerdNode* restriction, + const SerdNode* klass) +{ + // Check immediate instances of this class + SerdIter* i = serd_model_find(model, NULL, uris->rdf_type, klass, NULL); + SERD_FOREACH (s, i) { + check_instance( + model, uris, restriction, s, serd_statement_get_subject(s)); + } + serd_iter_free(i); + + // Check instances of all subclasses recursively + SerdIter* s = + serd_model_find(model, NULL, uris->rdfs_subClassOf, klass, NULL); + SERD_FOREACH (statement, s) { + const SerdNode* subklass = serd_statement_get_subject(statement); + check_class_instances(model, uris, restriction, subklass); + } + serd_iter_free(s); + + return 0; +} + +static int +check_instances(SerdModel* model, const URIs* uris) +{ + int st = 0; + SerdIter* r = serd_model_find( + model, NULL, uris->rdf_type, uris->owl_Restriction, NULL); + SERD_FOREACH (s, r) { + const SerdNode* restriction = serd_statement_get_subject(s); + const SerdNode* prop = serd_model_get( + model, restriction, uris->owl_onProperty, NULL, NULL); + if (!prop) { + continue; + } + + SerdIter* c = serd_model_find( + model, NULL, uris->rdfs_subClassOf, restriction, NULL); + SERD_FOREACH (t, c) { + const SerdNode* klass = serd_statement_get_subject(t); + check_class_instances(model, uris, restriction, klass); + } + serd_iter_free(c); + } + serd_iter_free(r); + + return st; +} + +static int +missing_arg(const char* name, char opt) +{ + ERRORF("option requires an argument -- '%c'\n", opt); + return print_usage(name, true); +} + +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] == '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) { + ERRORF("stack size `%ld' out of range\n", stack_size); + return 1; + } + } else if (argv[a][1] == 'l') { + one_line_errors = true; + } else if (argv[a][1] == 'v') { + return print_version(); + } else { + fprintf(stderr, "%s: Unknown option `%s'\n", argv[0], argv[a]); + 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); + + const SerdSinkInterface* sink = serd_inserter_get_sink_interface(inserter); + + // FIXME: syntax + SerdReader* reader = serd_reader_new(world, SERD_TURTLE, sink, stack_size); + + for (; a < argc; ++a) { + const char* input = argv[a]; + char* in_path = absolute_path(input); + + if (!in_path) { + fprintf(stderr, "Skipping file %s\n", input); + continue; + } + + SerdNode* base_uri_node = serd_node_new_file_uri(in_path, NULL, true); + + 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_end_stream(reader); + + if (st) { + fprintf(stderr, + "error reading %s: %s\n", + in_path, + serd_strerror(st)); + } + + serd_node_free(base_uri_node); + free(in_path); + } + serd_reader_free(reader); + serd_env_free(env); + +#define URI(prefix, suffix) \ + uris.prefix##_##suffix = serd_node_new_uri(NS_##prefix #suffix) + + URIs uris; + URI(foaf, Document); + URI(owl, AnnotationProperty); + URI(owl, Class); + URI(owl, DatatypeProperty); + URI(owl, FunctionalProperty); + URI(owl, InverseFunctionalProperty); + URI(owl, ObjectProperty); + URI(owl, OntologyProperty); + URI(owl, Restriction); + URI(owl, Thing); + 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, decimal); + URI(xsd, double); + URI(xsd, maxInclusive); + URI(xsd, minInclusive); + URI(xsd, pattern); + URI(xsd, string); + +#ifndef HAVE_PCRE + fprintf(stderr, "warning: Built without PCRE, datatypes not checked.\n"); +#endif + + const int prop_st = check_properties(model, &uris); + const int inst_st = check_instances(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 prop_st || inst_st; +} |