static void rdfa_report_error(void* parser_context, char* msg, ...)
{
char error[1024];
char* eptr;
va_list args;
rdfacontext* context = (rdfacontext*)parser_context;
/* format the error message */
va_start(args, msg);
vsprintf(error, msg, args);
va_end(args);
/* Remove any newlines from the libxml2 error */
eptr = error;
while(*eptr != '\0')
{
if(*eptr == '\n')
{
*eptr = '.';
}
eptr++;
}
/* Generate the processor error */
rdfa_processor_triples(context, RDFA_PROCESSOR_ERROR, error);
}
/**
* Attempts to update the uri mappings in the given context using the
* given attribute/value pair.
*
* @param attribute the attribute, which must start with xmlns.
* @param value the value of the attribute
*/
void rdfa_update_uri_mappings(
rdfacontext* context, const char* attr, const char* value)
{
#ifdef LIBRDFA_IN_RAPTOR
raptor_namespace_stack* nstack;
nstack = &context->sax2->namespaces;
#endif
/* * the [current element] is parsed for [URI mappings] and these
* are added to the [list of URI mappings]. Note that a [URI
* mapping] will simply overwrite any current mapping in the list
* that has the same name; */
/* Mappings are provided by @xmlns. The value to be mapped is set
* by the XML namespace prefix, and the value to map is the value
* of the attribute -- a URI. Note that the URI is not processed
* in any way; in particular if it is a relative path it is not
* resolved against the [current base]. Authors are advised to
* follow best practice for using namespaces, which includes not
* using relative paths. */
if(attr == NULL)
{
#ifdef LIBRDFA_IN_RAPTOR
raptor_namespaces_start_namespace_full(nstack,
NULL,
(const unsigned char*)value,
0);
#else
rdfa_update_mapping(
context->uri_mappings, XMLNS_DEFAULT_MAPPING, value,
(update_mapping_value_fp)rdfa_replace_string);
#endif
}
else if(strcmp(attr, "_") == 0)
{
#define FORMAT_1 "The underscore character must not be declared as a prefix " \
"because it conflicts with the prefix for blank node identifiers. " \
"The occurrence of this prefix declaration is being ignored."
#ifdef LIBRDFA_IN_RAPTOR
raptor_parser_warning((raptor_parser*)context->callback_data,
FORMAT_1);
#else
rdfa_processor_triples(context,
RDFA_PROCESSOR_WARNING,
FORMAT_1);
#endif
}
else if(attr[0] == ':' || attr[0] == '_' ||
(attr[0] >= 'A' && attr[0] <= 'Z') ||
(attr[0] >= 'a' && attr[0] <= 'z') ||
((unsigned char)attr[0] >= 0xc0 && (unsigned char)attr[0] <= 0xd6) ||
((unsigned char)attr[0] >= 0xd8 && (unsigned char)attr[0] <= 0xf6) || (unsigned char)attr[0] >= 0xf8)
{
#ifdef LIBRDFA_IN_RAPTOR
raptor_namespaces_start_namespace_full(nstack,
(const unsigned char*)attr,
(const unsigned char*)value,
0);
#else
rdfa_generate_namespace_triple(context, attr, value);
rdfa_update_mapping(context->uri_mappings, attr, value,
(update_mapping_value_fp)rdfa_replace_string);
#endif
}
else
{
/* allowable characters for CURIEs:
* ":" | [A-Z] | "_" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] |
* [#x370-#x37D] | [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] |
* [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD]
* | [#x10000-#xEFFFF]
*/
/* Generate the processor warning if this is an invalid prefix */
#define FORMAT_2 "The declaration of the '%s' prefix is invalid " \
"because it starts with an invalid character. Please see " \
"http://www.w3.org/TR/REC-xml/#NT-NameStartChar for a " \
"full explanation of valid first characters for declaring " \
"prefixes."
#ifdef LIBRDFA_IN_RAPTOR
raptor_parser_warning((raptor_parser*)context->callback_data,
FORMAT_2, attr);
#else
char msg[1024];
snprintf(msg, 1024, FORMAT_1);
rdfa_processor_triples(context, RDFA_PROCESSOR_WARNING, msg);
#endif
}
#ifdef LIBRDFA_IN_RAPTOR
#else
/* print the current mapping */
if(DEBUG)
{
printf("DEBUG: PREFIX MAPPINGS:");
rdfa_print_mapping(context->uri_mappings,
(print_mapping_value_fp)rdfa_print_string);
}
#endif
}
char* rdfa_resolve_curie(
rdfacontext* context, const char* uri, curieparse_t mode)
{
char* rval = NULL;
curie_t ctype = rdfa_get_curie_type(uri);
if(!uri)
return NULL;
if(ctype == CURIE_TYPE_INVALID)
{
rval = NULL;
}
else if((ctype == CURIE_TYPE_IRI_OR_UNSAFE) &&
((mode == CURIE_PARSE_HREF_SRC) ||
(context->rdfa_version == RDFA_VERSION_1_0 &&
mode == CURIE_PARSE_ABOUT_RESOURCE)))
{
/* If we are parsing something that can take either a CURIE or a
* URI, and the type is either IRI or UNSAFE, assume that it is
* an IRI */
rval = rdfa_resolve_uri(context, uri);
}
/*
* Check to see if the value is a term.
*/
if(ctype == CURIE_TYPE_IRI_OR_UNSAFE && mode == CURIE_PARSE_PROPERTY)
{
const char* term_iri;
term_iri = (const char*)rdfa_get_mapping(context->term_mappings, uri);
if(term_iri != NULL)
{
rval = strdup(term_iri);
}
else if(context->default_vocabulary == NULL && strstr(uri, ":") == NULL)
{
/* Generate the processor warning if this is a missing term */
#define FORMAT_1 "The use of the '%s' term was unrecognized by the RDFa processor because it is not a valid term for the current Host Language."
#ifdef LIBRDFA_IN_RAPTOR
raptor_parser_warning((raptor_parser*)context->callback_data,
FORMAT_1, uri);
#else
char msg[1024];
snprintf(msg, 1024, FORMAT_1, uri);
rdfa_processor_triples(context, RDFA_PROCESSOR_WARNING, msg);
#endif
}
}
/* if we are processing a safe CURIE OR
* if we are parsing an unsafe CURIE that is an @type_of,
* @datatype, @property, @rel, or @rev attribute, treat the curie
* as not an IRI, but an unsafe CURIE */
if(rval == NULL && ((ctype == CURIE_TYPE_SAFE) ||
((ctype == CURIE_TYPE_IRI_OR_UNSAFE) &&
((mode == CURIE_PARSE_INSTANCEOF_DATATYPE) ||
(mode == CURIE_PARSE_PROPERTY) ||
(mode == CURIE_PARSE_RELREV) ||
(context->rdfa_version == RDFA_VERSION_1_1 &&
mode == CURIE_PARSE_ABOUT_RESOURCE)))))
{
char* working_copy = NULL;
char* wcptr = NULL;
char* prefix = NULL;
char* curie_reference = NULL;
const char* expanded_prefix = NULL;
size_t uri_len = strlen(uri);
working_copy = (char*)malloc(uri_len + 1);
memcpy(working_copy, uri, uri_len + 1);/*rdfa_replace_string(working_copy, uri);*/
/* if this is a safe CURIE, chop off the beginning and the end */
if(ctype == CURIE_TYPE_SAFE)
{
prefix = strtok_r(working_copy, "[:]", &wcptr);
if(wcptr)
curie_reference = strtok_r(NULL, "[]", &wcptr);
}
else if(ctype == CURIE_TYPE_IRI_OR_UNSAFE)
{
prefix = strtok_r(working_copy, ":", &wcptr);
if(wcptr)
curie_reference = strtok_r(NULL, "", &wcptr);
}
/* fully resolve the prefix and get its length */
/* if a colon was found, but no prefix, use the XHTML vocabulary URI
* as the expanded prefix */
if((uri[0] == ':') || (strcmp(uri, "[:]") == 0))
{
expanded_prefix = XHTML_VOCAB_URI;
curie_reference = prefix;
prefix = NULL;
}
else if(uri[0] == ':')
{
/* FIXME: This looks like a bug - don't know why this code is
* in here. I think it's for the case where ":next" is
* specified, but the code's not checking that -- manu */
expanded_prefix = context->base;
curie_reference = prefix;
prefix = NULL;
}
else if(prefix != NULL)
{
if((mode != CURIE_PARSE_PROPERTY) &&
(mode != CURIE_PARSE_RELREV) &&
strcmp(prefix, "_") == 0)
{
/* if the prefix specifies this as a blank node, then we
* use the blank node prefix */
expanded_prefix = "_";
}
else
{
/* if the prefix was defined, get it from the set of URI mappings. */
#ifdef LIBRDFA_IN_RAPTOR
if(!strcmp(prefix, "xml"))
{
expanded_prefix = RAPTOR_GOOD_CAST(const char*, raptor_xml_namespace_uri);
}
else
{
raptor_namespace *nspace;
raptor_uri* ns_uri;
nspace = raptor_namespaces_find_namespace(&context->sax2->namespaces,
(const unsigned char*)prefix,
(int)strlen(prefix));
if(nspace) {
ns_uri = raptor_namespace_get_uri(nspace);
if(ns_uri)
expanded_prefix = (const char*)raptor_uri_as_string(ns_uri);
}
}
#else
expanded_prefix =
rdfa_get_mapping(context->uri_mappings, prefix);
/* Generate the processor warning if the prefix was not found */
if(expanded_prefix == NULL && strstr(uri, ":") != NULL &&
strstr(uri, "://") == NULL)
{
#define FORMAT_2 "The '%s' prefix was not found. You may want to check that it is declared before it is used, or that it is a valid prefix string."
#ifdef LIBRDFA_IN_RAPTOR
raptor_parser_warning((raptor_parser*)context->callback_data,
FORMAT_2, prefix);
#else
char msg[1024];
snprintf(msg, 1024, FORMAT_2, prefix);
rdfa_processor_triples(context, RDFA_PROCESSOR_WARNING, msg);
#endif
}
#endif
}
