static void
raptor_dot_serializer_write_uri(raptor_serializer* serializer,
raptor_uri* uri)
{
raptor_dot_context* context = (raptor_dot_context*)serializer->context;
unsigned char* full = raptor_uri_as_string(uri);
int i;
for( i = 0 ; i < raptor_sequence_size(context->namespaces) ; i++ ) {
raptor_namespace* ns =
(raptor_namespace*)raptor_sequence_get_at(context->namespaces, i);
const unsigned char* ns_uri_string;
size_t ns_uri_string_len;
ns_uri_string=raptor_uri_as_counted_string(ns->uri, &ns_uri_string_len);
if(!strncmp((char*)full, (char*)ns_uri_string, ns_uri_string_len) ) {
const unsigned char* prefix = raptor_namespace_get_prefix(ns);
if(prefix) {
raptor_iostream_write_string(serializer->iostream, prefix);
raptor_iostream_write_byte(serializer->iostream, ':');
}
raptor_iostream_write_string(serializer->iostream,
full + ns_uri_string_len);
return;
}
}
raptor_iostream_write_string(serializer->iostream, full);
}
static void
rasqal_query_write_sparql_uri(sparql_writer_context *wc,
raptor_iostream* iostr, raptor_uri* uri)
{
size_t len;
unsigned char* string;
raptor_qname* qname;
qname = raptor_new_qname_from_namespace_uri(wc->nstack, uri, 10);
if(qname) {
const raptor_namespace* nspace = raptor_qname_get_namespace(qname);
if(!raptor_namespace_get_prefix(nspace))
raptor_iostream_write_byte(':', iostr);
raptor_qname_write(qname, iostr);
raptor_free_qname(qname);
return;
}
if(wc->base_uri)
string = raptor_uri_to_relative_counted_uri_string(wc->base_uri, uri, &len);
else
string = raptor_uri_as_counted_string(uri, &len);
raptor_iostream_write_byte('<', iostr);
raptor_string_ntriples_write(string, len, '>', iostr);
raptor_iostream_write_byte('>', iostr);
if(wc->base_uri)
raptor_free_memory(string);
}
/**
* raptor_turtle_writer_namespace_prefix:
* @turtle_writer: Turtle writer object
* @ns: Namespace to write prefix declaration for
*
* Write a namespace prefix declaration (@prefix)
*
* Must only be used at the beginning of a document.
*/
void
raptor_turtle_writer_namespace_prefix(raptor_turtle_writer* turtle_writer,
raptor_namespace* ns)
{
raptor_iostream_string_write("@prefix ", turtle_writer->iostr);
if(ns->prefix)
raptor_iostream_string_write(raptor_namespace_get_prefix(ns),
turtle_writer->iostr);
raptor_iostream_counted_string_write(": ", 2, turtle_writer->iostr);
raptor_turtle_writer_reference(turtle_writer, raptor_namespace_get_uri(ns));
raptor_iostream_counted_string_write(" .\n", 3, turtle_writer->iostr);
}
/**
* raptor_serializer_set_namespace_from_namespace:
* @rdf_serializer: the #raptor_serializer
* @nspace: #raptor_namespace to set
*
* Set a namespace uri/prefix mapping for serializing from an existing namespace.
*
* Return value: non-0 on failure.
**/
int
raptor_serializer_set_namespace_from_namespace(raptor_serializer* rdf_serializer,
raptor_namespace *nspace)
{
if(rdf_serializer->factory->declare_namespace_from_namespace)
return rdf_serializer->factory->declare_namespace_from_namespace(rdf_serializer,
nspace);
else if(rdf_serializer->factory->declare_namespace)
return rdf_serializer->factory->declare_namespace(rdf_serializer,
raptor_namespace_get_uri(nspace),
raptor_namespace_get_prefix(nspace));
return 1;
}
// static
void CRDFParser::NameSpaceHandler(void * pGraph, raptor_namespace * pNameSpace)
{
const unsigned char * pURI =
raptor_uri_as_string(raptor_namespace_get_uri(pNameSpace));
std::string URI("");
if (pURI) URI = (const char *) pURI;
const unsigned char * pPrefix =
raptor_namespace_get_prefix(pNameSpace);
std::string Prefix("");
if (pPrefix) Prefix = (const char *) pPrefix;
static_cast<CRDFGraph *>(pGraph)->addNameSpace(Prefix, URI);
}
/* end a serialize */
static int
raptor_dot_serializer_end(raptor_serializer* serializer)
{
raptor_dot_context* context=(raptor_dot_context*)serializer->context;
raptor_dot_serializer_node* node;
int i;
/* Print our nodes. */
raptor_iostream_write_string(serializer->iostream,
(const unsigned char *)"\n\t// Resources\n");
for( i = 0 ; i < raptor_sequence_size(context->resources) ; i++ ) {
node = (raptor_dot_serializer_node*)raptor_sequence_get_at(context->resources, i);
raptor_iostream_write_string(serializer->iostream,
(const unsigned char *)"\t\"R");
raptor_dot_serializer_write_node(serializer, node->value.resource.uri,
RAPTOR_IDENTIFIER_TYPE_RESOURCE, NULL, NULL);
raptor_iostream_write_string(serializer->iostream,
(const unsigned char *)"\" [ label=\"");
raptor_dot_serializer_write_node(serializer, node->value.resource.uri,
RAPTOR_IDENTIFIER_TYPE_RESOURCE, NULL, NULL);
raptor_iostream_write_string(serializer->iostream,
(const unsigned char *)"\", shape=ellipse");
raptor_dot_serializer_write_colors(serializer,
RAPTOR_IDENTIFIER_TYPE_RESOURCE);
raptor_iostream_write_string(serializer->iostream,
(const unsigned char *)" ];\n");
}
raptor_free_sequence(context->resources);
raptor_iostream_write_string(serializer->iostream,
(const unsigned char *)"\n\t// Anonymous nodes\n");
for( i = 0 ; i < raptor_sequence_size(context->bnodes) ; i++ ) {
node = (raptor_dot_serializer_node *)raptor_sequence_get_at(context->bnodes, i);
raptor_iostream_write_string(serializer->iostream,
(const unsigned char *)"\t\"B");
raptor_dot_serializer_write_node(serializer, node->value.resource.uri,
RAPTOR_IDENTIFIER_TYPE_ANONYMOUS, NULL, NULL);
raptor_iostream_write_string(serializer->iostream,
(const unsigned char *)"\" [ label=\"");
raptor_iostream_write_string(serializer->iostream,
(const unsigned char *)"\", shape=circle");
raptor_dot_serializer_write_colors(serializer,
RAPTOR_IDENTIFIER_TYPE_ANONYMOUS);
raptor_iostream_write_string(serializer->iostream,
(const unsigned char *)" ];\n");
}
raptor_free_sequence(context->bnodes);
raptor_iostream_write_string(serializer->iostream,
(const unsigned char *)"\n\t// Literals\n");
for( i = 0 ; i < raptor_sequence_size(context->literals) ; i++ ) {
node = (raptor_dot_serializer_node *)raptor_sequence_get_at(context->literals, i);
raptor_iostream_write_string(serializer->iostream,
(const unsigned char *)"\t\"L");
raptor_dot_serializer_write_node(serializer, node->value.literal.string,
RAPTOR_IDENTIFIER_TYPE_LITERAL,
node->value.literal.datatype,
node->value.literal.language);
raptor_iostream_write_string(serializer->iostream,
(const unsigned char *)"\" [ label=\"");
raptor_dot_serializer_write_node(serializer, node->value.literal.string,
RAPTOR_IDENTIFIER_TYPE_LITERAL,
node->value.literal.datatype,
node->value.literal.language);
raptor_iostream_write_string(serializer->iostream,
(const unsigned char *)"\", shape=record");
raptor_dot_serializer_write_colors(serializer,
RAPTOR_IDENTIFIER_TYPE_LITERAL);
raptor_iostream_write_string(serializer->iostream,
(const unsigned char *)" ];\n");
}
raptor_free_sequence(context->literals);
raptor_iostream_write_string(serializer->iostream,
(const unsigned char *)"\n\tlabel=\"\\n\\nModel:\\n");
if(serializer->base_uri)
raptor_iostream_write_string(serializer->iostream,
raptor_uri_as_string(serializer->base_uri));
else
raptor_iostream_write_string(serializer->iostream, "(Unknown)");
if(raptor_sequence_size(context->namespaces)) {
raptor_iostream_write_string(serializer->iostream,
(const unsigned char *)"\\n\\nNamespaces:\\n");
for( i = 0 ; i < raptor_sequence_size(context->namespaces) ; i++ ) {
raptor_namespace* ns =
(raptor_namespace*)raptor_sequence_get_at(context->namespaces, i);
const unsigned char* prefix = raptor_namespace_get_prefix(ns);
if(prefix) {
raptor_iostream_write_string(serializer->iostream,
(const unsigned char *)ns->prefix);
raptor_iostream_write_string(serializer->iostream,
(const unsigned char *)": ");
}
raptor_iostream_write_string(serializer->iostream,
raptor_uri_as_string(ns->uri));
raptor_iostream_write_string(serializer->iostream,
(const unsigned char *)"\\n");
}
raptor_free_sequence(context->namespaces);
}
raptor_iostream_write_string(serializer->iostream,
(const unsigned char *)"\";\n");
raptor_iostream_write_string(serializer->iostream,
(const unsigned char *) "}\n");
return 0;
}
/* end a serialize */
static int
raptor_dot_serializer_end(raptor_serializer* serializer)
{
raptor_dot_context* context = (raptor_dot_context*)serializer->context;
raptor_term* node;
int i;
/* Print our nodes. */
raptor_iostream_string_write((const unsigned char*)"\n\t// Resources\n",
serializer->iostream);
for(i = 0 ; i < raptor_sequence_size(context->resources) ; i++ ) {
node = (raptor_term*)raptor_sequence_get_at(context->resources, i);
raptor_iostream_string_write((const unsigned char*)"\t\"R",
serializer->iostream);
raptor_dot_serializer_write_term(serializer, node);
raptor_iostream_string_write((const unsigned char*)"\" [ label=\"",
serializer->iostream);
raptor_dot_serializer_write_term(serializer, node);
raptor_iostream_string_write((const unsigned char*)"\", shape = ellipse",
serializer->iostream);
raptor_dot_serializer_write_colors(serializer, RAPTOR_TERM_TYPE_URI);
raptor_iostream_string_write((const unsigned char*)" ];\n",
serializer->iostream);
}
raptor_free_sequence(context->resources);
raptor_iostream_string_write((const unsigned char*)"\n\t// Anonymous nodes\n",
serializer->iostream);
for(i = 0 ; i < raptor_sequence_size(context->bnodes) ; i++ ) {
node = (raptor_term *)raptor_sequence_get_at(context->bnodes, i);
raptor_iostream_string_write((const unsigned char*)"\t\"B",
serializer->iostream);
raptor_dot_serializer_write_term(serializer, node);
raptor_iostream_string_write((const unsigned char*)"\" [ label=\"",
serializer->iostream);
raptor_iostream_string_write((const unsigned char*)"\", shape = circle",
serializer->iostream);
raptor_dot_serializer_write_colors(serializer, RAPTOR_TERM_TYPE_BLANK);
raptor_iostream_string_write((const unsigned char*)" ];\n",
serializer->iostream);
}
raptor_free_sequence(context->bnodes);
raptor_iostream_string_write((const unsigned char*)"\n\t// Literals\n",
serializer->iostream);
for(i = 0 ; i < raptor_sequence_size(context->literals) ; i++ ) {
node = (raptor_term*)raptor_sequence_get_at(context->literals, i);
raptor_iostream_string_write((const unsigned char*)"\t\"L",
serializer->iostream);
raptor_dot_serializer_write_term(serializer, node);
raptor_iostream_string_write((const unsigned char*)"\" [ label=\"",
serializer->iostream);
raptor_dot_serializer_write_term(serializer, node);
raptor_iostream_string_write((const unsigned char*)"\", shape = record",
serializer->iostream);
raptor_dot_serializer_write_colors(serializer, RAPTOR_TERM_TYPE_LITERAL);
raptor_iostream_string_write((const unsigned char*)" ];\n",
serializer->iostream);
}
raptor_free_sequence(context->literals);
raptor_iostream_string_write((const unsigned char*)"\n\tlabel=\"\\n\\nModel:\\n",
serializer->iostream);
if(serializer->base_uri)
raptor_iostream_string_write(raptor_uri_as_string(serializer->base_uri),
serializer->iostream);
else
raptor_iostream_string_write("(Unknown)", serializer->iostream);
if(raptor_sequence_size(context->namespaces)) {
raptor_iostream_string_write((const unsigned char*)"\\n\\nNamespaces:\\n",
serializer->iostream);
for(i = 0 ; i < raptor_sequence_size(context->namespaces) ; i++ ) {
raptor_namespace* ns;
const unsigned char* prefix;
ns = (raptor_namespace*)raptor_sequence_get_at(context->namespaces, i);
prefix = raptor_namespace_get_prefix(ns);
if(prefix) {
raptor_iostream_string_write((const unsigned char*)ns->prefix,
serializer->iostream);
raptor_iostream_string_write((const unsigned char*)": ",
serializer->iostream);
}
raptor_iostream_string_write(raptor_uri_as_string(ns->uri),
serializer->iostream);
raptor_iostream_string_write((const unsigned char*)"\\n",
serializer->iostream);
}
raptor_free_sequence(context->namespaces);
}
raptor_iostream_string_write((const unsigned char*)"\";\n",
serializer->iostream);
raptor_iostream_string_write((const unsigned char*) "}\n",
serializer->iostream);
return 0;
}
/**
* Handles the start_element call
*/
static void start_element(void *parser_context, const char* name,
const char* prefix, const char* URI, int nb_namespaces,
const char** namespaces, int nb_attributes, int nb_defaulted,
const char** attributes)
{
rdfacontext* root_context = (rdfacontext*)parser_context;
rdfalist* context_stack = (rdfalist*)root_context->context_stack;
rdfacontext* context = rdfa_create_new_element_context(context_stack);
char* xml_lang = NULL;
const char* about_curie = NULL;
char* about = NULL;
const char* src_curie = NULL;
char* src = NULL;
const char* type_of_curie = NULL;
rdfalist* type_of = NULL;
const char* rel_curie = NULL;
rdfalist* rel = NULL;
const char* rev_curie = NULL;
rdfalist* rev = NULL;
const char* property_curie = NULL;
rdfalist* property = NULL;
const char* resource_curie = NULL;
char* resource = NULL;
const char* href_curie = NULL;
char* href = NULL;
char* content = NULL;
const char* datatype_curie = NULL;
char* datatype = NULL;
#ifdef LIBRDFA_IN_RAPTOR
if(1) {
raptor_parser* rdf_parser = (raptor_parser*)context->callback_data;
raptor_sax2_update_document_locator(context->sax2,
&rdf_parser->locator);
}
#endif
rdfa_push_item(context_stack, context, RDFALIST_FLAG_CONTEXT);
#if defined(DEBUG) && DEBUG > 0
if(1) {
int i;
/* dump all arguments sent to this callback */
fprintf(stdout, "DEBUG: SAX.startElementNs(%s", (char *) name);
if (prefix == NULL)
fprintf(stdout, ", NULL");
else
fprintf(stdout, ", %s", (char *) prefix);
if (URI == NULL)
fprintf(stdout, ", NULL");
else
fprintf(stdout, ", '%s'", (char *) URI);
fprintf(stdout, ", %d", nb_namespaces);
/* dump all namespaces */
if (namespaces != NULL) {
for (i = 0;i < nb_namespaces * 2;i++) {
fprintf(stdout, ", xmlns");
if (namespaces[i] != NULL)
fprintf(stdout, ":%s", namespaces[i]);
i++;
fprintf(stdout, "='%s'", namespaces[i]);
}
}
/* dump all attributes */
fprintf(stdout, ", %d, %d", nb_attributes, nb_defaulted);
if (attributes != NULL) {
for (i = 0;i < nb_attributes * 5;i += 5) {
if (attributes[i + 1] != NULL)
fprintf(
stdout, ", %s:%s='", attributes[i + 1], attributes[i]);
else
fprintf(stdout, ", %s='", attributes[i]);
fprintf(stdout, "%.4s...', %d", attributes[i + 3],
(int)(attributes[i + 4] - attributes[i + 3]));
}
}
fprintf(stdout, ")\n");
}
#endif
/* start the XML Literal text */
if(context->xml_literal == NULL)
{
context->xml_literal = rdfa_replace_string(context->xml_literal, "<");
context->xml_literal_size = 1;
}
else
{
context->xml_literal = rdfa_n_append_string(
context->xml_literal, &context->xml_literal_size, "<", 1);
}
context->xml_literal = rdfa_n_append_string(
context->xml_literal, &context->xml_literal_size,
name, strlen(name));
if(!context->xml_literal_namespaces_defined)
{
/* append namespaces to XML Literal */
#ifdef LIBRDFA_IN_RAPTOR
raptor_namespace_stack* nstack = &context->sax2->namespaces;
raptor_namespace* ns;
raptor_namespace** ns_list = NULL;
size_t ns_size;
#else
void** umap = context->uri_mappings;
#endif
char* umap_key = NULL;
void* umap_value = NULL;
/* if the namespaces are not defined, then neither is the xml:lang */
context->xml_literal_xml_lang_defined = 0;
#ifdef LIBRDFA_IN_RAPTOR
ns_size = 0;
ns_list = raptor_namespace_stack_to_array(nstack, &ns_size);
qsort((void*)ns_list, ns_size, sizeof(raptor_namespace*),
raptor_nspace_compare);
while(ns_size > 0)
#else
while(*umap != NULL)
#endif
{
unsigned char insert_xmlns_definition = 1;
const char* attr = NULL;
/* get the next mapping to process */
#ifdef LIBRDFA_IN_RAPTOR
ns=ns_list[--ns_size];
umap_key = (char*)raptor_namespace_get_prefix(ns);
if(!umap_key)
umap_key=(char*)XMLNS_DEFAULT_MAPPING;
umap_value = (char*)raptor_uri_as_string(raptor_namespace_get_uri(ns));
#else
rdfa_next_mapping(umap++, &umap_key, &umap_value);
umap++;
#endif
/* check to make sure that the namespace isn't already
* defined in the current element. */
if(attributes != NULL)
{
const char** attrs = attributes;
while((*attrs != NULL) && insert_xmlns_definition)
{
attr = *attrs++;
/* if the attribute is a umap_key, skip the definition
* of the attribute. */
if(strcmp(attr, umap_key) == 0)
{
insert_xmlns_definition = 0;
}
}
}
/* if the namespace isn't already defined on the element,
* copy it to the XML Literal string. */
if(insert_xmlns_definition)
{
/* append the namespace attribute to the XML Literal */
context->xml_literal = rdfa_n_append_string(
context->xml_literal, &context->xml_literal_size,
" xmlns", strlen(" xmlns"));
/* check to see if we're dumping the standard XHTML namespace or
* a user-defined XML namespace */
if(strcmp(umap_key, XMLNS_DEFAULT_MAPPING) != 0)
{
context->xml_literal = rdfa_n_append_string(
context->xml_literal, &context->xml_literal_size, ":", 1);
context->xml_literal = rdfa_n_append_string(
context->xml_literal, &context->xml_literal_size,
umap_key, strlen(umap_key));
}
/* append the namespace value */
context->xml_literal = rdfa_n_append_string(
context->xml_literal, &context->xml_literal_size, "=\"", 2);
context->xml_literal = rdfa_n_append_string(
context->xml_literal, &context->xml_literal_size,
(const char*)umap_value, strlen((char*)umap_value));
context->xml_literal = rdfa_n_append_string(
context->xml_literal, &context->xml_literal_size, "\"", 1);
}
} /* end while umap not NULL */
context->xml_literal_namespaces_defined = 1;
#ifdef LIBRDFA_IN_RAPTOR
if(ns_list)
raptor_free_memory(ns_list);
#endif
} /* end if namespaces inserted */
#ifdef LIBRDFA_IN_RAPTOR
/* Raptor namespace code does this already */
#else
/* 3. For backward compatibility, RDFa Processors should also permit the
* definition of mappings via @xmlns. In this case, the value to be mapped
* is set by the XML namespace prefix, and the value to map is the value of
* the attribute - an IRI. (Note that prefix mapping via @xmlns is
* deprecated, and may be removed in a future version of this
* specification.) When xmlns is supported, such mappings must be processed
* before processing any mappings from @prefix on the same element. */
if(namespaces != NULL)
{
int ni;
for(ni = 0; ni < nb_namespaces * 2; ni += 2)
{
const char* ns = namespaces[ni];
const char* value = namespaces[ni + 1];
/* Regardless of how the mapping is declared, the value to be mapped
* must be converted to lower case, and the IRI is not processed in
* any way; in particular if it is a relative path it must not be
* resolved against the current base. */
char* lcns = NULL;
if(ns != NULL)
{
/* convert the namespace string to lowercase */
unsigned int i;
size_t ns_length = strlen(ns);
lcns = (char*)malloc(ns_length + 1);
for(i = 0; i <= ns_length; i++)
{
lcns[i] = tolower(ns[i]);
}
}
/* update the URI mappings */
rdfa_update_uri_mappings(context, lcns, value);
if(lcns != NULL)
{
free(lcns);
}
}
}
#endif
/* detect the RDFa version of the document, if specified */
if(attributes != NULL)
{
int ci;
/* search for a version attribute */
for(ci = 0; ci < nb_attributes * 5; ci += 5)
{
const char* attr;
char* value;
size_t value_length = 0;
attr = attributes[ci];
value_length = attributes[ci + 4] - attributes[ci + 3] + 1;
if(strcmp(attr, "version") == 0)
{
/* append the attribute-value pair to the XML literal */
value = (char*)malloc(value_length + 1);
snprintf(value, value_length, "%s", attributes[ci + 3]);
if(strstr(value, "RDFa 1.0") != NULL)
{
context->rdfa_version = RDFA_VERSION_1_0;
}
else if(strstr(value, "RDFa 1.1") != NULL)
{
context->rdfa_version = RDFA_VERSION_1_1;
}
free(value);
}
}
}
#ifdef LIBRDFA_IN_RAPTOR
if(context->sax2)
{
/* Raptor handles xml:lang itself but not 'lang' */
xml_lang = (char*)raptor_sax2_inscope_xml_language(context->sax2);
xml_lang = rdfa_replace_string(NULL, xml_lang);
}
#endif
/* prepare all of the RDFa-specific attributes we are looking for.
* scan all of the attributes for the RDFa-specific attributes */
if(attributes != NULL)
{
int ci;
if(context->rdfa_version == RDFA_VERSION_1_1)
{
/* process all vocab and prefix attributes */
for(ci = 0; ci < nb_attributes * 5; ci += 5)
{
const char* attr;
char* value;
size_t value_length = 0;
attr = attributes[ci];
value_length = attributes[ci + 4] - attributes[ci + 3] + 1;
/* append the attribute-value pair to the XML literal */
value = (char*)malloc(value_length + 1);
snprintf(value, value_length, "%s", attributes[ci + 3]);
/* 2. Next the current element is examined for any change to the
* default vocabulary via @vocab. */
if(strcmp(attr, "vocab") == 0)
{
if(strlen(value) < 1)
{
/* If the value is empty, then the local default vocabulary
* must be reset to the Host Language defined default
* (if any). */
free(context->default_vocabulary);
context->default_vocabulary = NULL;
}
else
{
char* resolved_uri;
rdftriple* triple;
/* If @vocab is present and contains a value, the local
* default vocabulary is updated according to the
* section on CURIE and IRI Processing. */
resolved_uri = rdfa_resolve_uri(context, value);
context->default_vocabulary = rdfa_replace_string(
context->default_vocabulary, resolved_uri);
/* The value of @vocab is used to generate a triple */
triple = rdfa_create_triple(
context->base, "http://www.w3.org/ns/rdfa#usesVocabulary",
resolved_uri, RDF_TYPE_IRI, NULL, NULL);
context->default_graph_triple_callback(
triple, context->callback_data);
free(resolved_uri);
}
}
else if(strcmp(attr, "prefix") == 0)
{
/* Mappings are defined via @prefix. */
char* working_string = NULL;
char* atprefix = NULL;
char* iri = NULL;
char* saveptr = NULL;
working_string = rdfa_replace_string(working_string, value);
/* Values in this attribute are evaluated from beginning to
* end (e.g., left to right in typical documents). */
atprefix = strtok_r(working_string, ":", &saveptr);
while(atprefix != NULL)
{
/* find the prefix and IRI mappings while skipping whitespace */
while((*saveptr == ' ' || *saveptr == '\n' ||
*saveptr == '\r' || *saveptr == '\t' || *saveptr == '\f' ||
*saveptr == '\v') && *saveptr != '\0')
{
saveptr++;
}
iri = strtok_r(NULL, RDFA_WHITESPACE, &saveptr);
/* update the prefix mappings */
rdfa_update_uri_mappings(context, atprefix, iri);
if(!saveptr)
break;
while((*saveptr == ' ' || *saveptr == '\n' ||
*saveptr == '\r' || *saveptr == '\t' || *saveptr == '\f' ||
*saveptr == '\v') && *saveptr != '\0')
{
saveptr++;
}
/* get the next prefix to process */
atprefix = strtok_r(NULL, ":", &saveptr);
}
free(working_string);
}
else if(strcmp(attr, "inlist") == 0)
{
context->inlist_present = 1;
}
free(value);
}
}
/* resolve all of the other RDFa values */
for(ci = 0; ci < nb_attributes * 5; ci += 5)
{
const char* attr;
char* value;
char* attrns;
char* literal_text;
size_t value_length = 0;
attr = attributes[ci];
attrns = (char*)attributes[ci + 1];
value_length = attributes[ci + 4] - attributes[ci + 3] + 1;
/* append the attribute-value pair to the XML literal */
value = (char*)malloc(value_length + 1);
literal_text = (char*)malloc(strlen(attr) + value_length + 5);
snprintf(value, value_length, "%s", attributes[ci + 3]);
sprintf(literal_text, " %s=\"%s\"", attr, value);
context->xml_literal = rdfa_n_append_string(
context->xml_literal, &context->xml_literal_size,
literal_text, strlen(literal_text));
free(literal_text);
/* if xml:lang is defined, ensure that it is not overwritten */
if(attrns != NULL && strcmp(attrns, "xml") == 0 &&
strcmp(attr, "lang") == 0)
{
context->xml_literal_xml_lang_defined = 1;
}
/* process all of the RDFa attributes */
if(strcmp(attr, "about") == 0)
{
about_curie = value;
about = rdfa_resolve_curie(
context, about_curie, CURIE_PARSE_ABOUT_RESOURCE);
}
else if(strcmp(attr, "src") == 0)
{
src_curie = value;
src = rdfa_resolve_curie(context, src_curie, CURIE_PARSE_HREF_SRC);
}
else if(strcmp(attr, "typeof") == 0)
{
type_of_curie = value;
type_of = rdfa_resolve_curie_list(
context, type_of_curie,
CURIE_PARSE_INSTANCEOF_DATATYPE);
}
else if(strcmp(attr, "rel") == 0)
{
context->rel_present = 1;
rel_curie = value;
rel = rdfa_resolve_curie_list(
context, rel_curie, CURIE_PARSE_RELREV);
}
else if(strcmp(attr, "rev") == 0)
{
context->rev_present = 1;
rev_curie = value;
rev = rdfa_resolve_curie_list(
context, rev_curie, CURIE_PARSE_RELREV);
}
else if(strcmp(attr, "property") == 0)
{
property_curie = value;
property =
rdfa_resolve_curie_list(
context, property_curie, CURIE_PARSE_PROPERTY);
}
else if(strcmp(attr, "resource") == 0)
{
resource_curie = value;
resource = rdfa_resolve_curie(
context, resource_curie, CURIE_PARSE_ABOUT_RESOURCE);
}
else if(strcmp(attr, "href") == 0)
{
href_curie = value;
href =
rdfa_resolve_curie(context, href_curie, CURIE_PARSE_HREF_SRC);
}
else if(strcmp(attr, "content") == 0)
{
content = rdfa_replace_string(content, value);
}
else if(strcmp(attr, "datatype") == 0)
{
datatype_curie = value;
if(strlen(datatype_curie) == 0)
{
datatype = rdfa_replace_string(datatype, "");
}
else
{
datatype = rdfa_resolve_curie(context, datatype_curie,
CURIE_PARSE_INSTANCEOF_DATATYPE);
}
}
else if((attrns == NULL && strcmp(attr, "lang") == 0) ||
(attrns != NULL && strcmp(attrns, "xml") == 0 &&
strcmp(attr, "lang") == 0))
{
xml_lang = rdfa_replace_string(xml_lang, value);
}
free(value);
}
}
/* The root element has an implicit @about declaration */
if(context->depth == 1 && about == NULL && resource == NULL &&
href == NULL && src == NULL)
{
about_curie = "";
about = rdfa_resolve_curie(
context, about_curie, CURIE_PARSE_ABOUT_RESOURCE);
}
/* The HEAD and BODY element in XHTML and HTML has an implicit
* about="" on it.
*/
if(about == NULL && resource == NULL && href == NULL && src == NULL &&
(context->parent_subject == NULL || type_of != NULL) &&
((context->host_language == HOST_LANGUAGE_XHTML1 ||
context->host_language == HOST_LANGUAGE_HTML) &&
(strcasecmp(name, "head") == 0 || strcasecmp(name, "body") == 0)))
{
about_curie = "";
about = rdfa_resolve_curie(
context, about_curie, CURIE_PARSE_ABOUT_RESOURCE);
}
/* check to see if we should append an xml:lang to the XML Literal
* if one is defined in the context and does not exist on the
* element. */
if((xml_lang == NULL) && (context->language != NULL) &&
!context->xml_literal_xml_lang_defined)
{
context->xml_literal = rdfa_n_append_string(
context->xml_literal, &context->xml_literal_size,
" xml:lang=\"", strlen(" xml:lang=\""));
context->xml_literal = rdfa_n_append_string(
context->xml_literal, &context->xml_literal_size,
context->language, strlen(context->language));
context->xml_literal = rdfa_n_append_string(
context->xml_literal, &context->xml_literal_size, "\"", 1);
/* ensure that the lang isn't set in a subtree (unless it's overwritten) */
context->xml_literal_xml_lang_defined = 1;
}
/* close the XML Literal value */
context->xml_literal = rdfa_n_append_string(
context->xml_literal, &context->xml_literal_size, ">", 1);
/* 3. The [current element] is also parsed for any language
* information, and [language] is set in the [current
* evaluation context]; */
rdfa_update_language(context, xml_lang);
/***************** FOR DEBUGGING PURPOSES ONLY ******************/
#if defined(DEBUG) && DEBUG > 0
printf("DEBUG: depth = %u\n", context->depth);
if(about != NULL)
{
printf("DEBUG: @about = %s\n", about);
}
if(src != NULL)
{
printf("DEBUG: @src = %s\n", src);
}
if(type_of != NULL)
{
printf("DEBUG: @type_of = ");
rdfa_print_list(type_of);
}
if(context->inlist_present)
{
printf("DEBUG: @inlist = true\n");
}
if(rel != NULL)
{
printf("DEBUG: @rel = ");
rdfa_print_list(rel);
}
if(rev != NULL)
{
printf("DEBUG: @rev = ");
rdfa_print_list(rev);
}
if(property != NULL)
{
printf("DEBUG: @property = ");
rdfa_print_list(property);
}
if(resource != NULL)
{
printf("DEBUG: @resource = %s\n", resource);
}
if(href != NULL)
{
printf("DEBUG: @href = %s\n", href);
}
if(content != NULL)
{
printf("DEBUG: @content = %s\n", content);
}
if(datatype != NULL)
{
printf("DEBUG: @datatype = %s\n", datatype);
}
if(xml_lang != NULL)
{
printf("DEBUG: @xml:lang = %s\n", xml_lang);
}
#endif
/* TODO: This isn't part of the processing model, it needs to be
* included and is a correction for the last item in step #4. */
if((about == NULL) && (src == NULL) && (type_of == NULL) &&
(rel == NULL) && (rev == NULL) && (property == NULL) &&
(resource == NULL) && (href == NULL) &&
(context->default_vocabulary == NULL) && (prefix == NULL))
{
context->skip_element = 1;
}
if((rel == NULL) && (rev == NULL))
{
if(context->rdfa_version == RDFA_VERSION_1_0)
{
/* 4. If the [current element] contains no valid @rel or @rev
* URI, obtained according to the section on CURIE and URI
* Processing, then the next step is to establish a value for
* [new subject]. Any of the attributes that can carry a
* resource can set [new subject]; */
rdfa_establish_new_1_0_subject(
context, name, about, src, resource, href, type_of);
}
else
{
rdfa_establish_new_1_1_subject(
context, name, about, src, resource, href, type_of, property,
content, datatype);
}
}
else
{
if(context->rdfa_version == RDFA_VERSION_1_0)
{
/* 5. If the [current element] does contain a valid @rel or @rev
* URI, obtained according to the section on CURIE and URI
* Processing, then the next step is to establish both a value
* for [new subject] and a value for [current object resource]: */
rdfa_establish_new_1_0_subject_with_relrev(
context, name, about, src, resource, href, type_of);
}
else
{
rdfa_establish_new_1_1_subject_with_relrev(
context, name, about, src, resource, href, type_of);
}
}
if(context->new_subject != NULL)
{
#if defined(DEBUG) && DEBUG > 0
printf("DEBUG: new_subject = %s\n", context->new_subject);
#endif
/* RDFa 1.0: 6. If in any of the previous steps a [new subject] was set
* to a non-null value, it is now used to provide a subject for
* type values; */
/* RDFa 1.1: 7. If in any of the previous steps a typed resource was set
* to a non-null value, it is now used to provide a subject for type
* values;
*/
if(type_of != NULL)
{
rdfa_complete_type_triples(context, type_of);
}
/* Note that none of this block is executed if there is no
* [new subject] value, i.e., [new subject] remains null. */
}
if(context->current_object_resource != NULL)
{
/* If the element contains both the @inlist and the @rel attributes:
* the @rel may contain one or more resources, obtained according to
* the section on CURIE and IRI Processing each of which is used to
* add an entry to the list mapping as follows:
* if the local list mapping does not contain a list associated with
* the IRI, instantiate a new list and add to local list mappings
* add the current object resource to the list associated with the
* resource in the local list mapping */
if(context->rdfa_version == RDFA_VERSION_1_1 && (rel != NULL) &&
context->inlist_present)
{
rdfresource_t object_type = RDF_TYPE_IRI;
if((property != NULL) || (content != NULL))
{
object_type = RDF_TYPE_PLAIN_LITERAL;
if(datatype != NULL)
{
object_type = RDF_TYPE_TYPED_LITERAL;
}
}
rdfa_establish_new_inlist_triples(
context, rel, context->current_object_resource, object_type);
}
/* 7. If in any of the previous steps a [current object resource]
* was set to a non-null value, it is now used to generate triples */
rdfa_complete_relrev_triples(context, rel, rev);
}
if((context->current_object_resource == NULL) &&
context->rdfa_version == RDFA_VERSION_1_1 && (rel != NULL) &&
context->inlist_present)
{
rdfa_save_incomplete_list_triples(context, rel);
}
else if((context->current_object_resource == NULL) &&
((rel != NULL) || (rev != NULL)))
{
/* 8. If however [current object resource] was set to null, but
* there are predicates present, then they must be stored as
* [incomplete triple]s, pending the discovery of a subject that
* can be used as the object. Also, [current object resource]
* should be set to a newly created [bnode] */
rdfa_save_incomplete_triples(context, rel, rev);
}
/* Ensure to re-insert XML Literal namespace information from this
* point on... */
if(property != NULL)
{
context->xml_literal_namespaces_defined = 0;
}
/* save these for processing steps #9 and #10 */
context->about = rdfa_replace_string(context->about, about);
context->resource = rdfa_replace_string(context->resource, resource);
context->href = rdfa_replace_string(context->href, href);
context->src = rdfa_replace_string(context->src, src);
context->content = rdfa_replace_string(context->content, content);
context->datatype = rdfa_replace_string(context->datatype, datatype);
context->property = property;
/* free the resolved CURIEs */
free(about);
free(src);
rdfa_free_list(type_of);
rdfa_free_list(rel);
rdfa_free_list(rev);
free(xml_lang);
free(content);
free(resource);
free(href);
free(datatype);
}
static void raptor_rdfa_start_element(void *user_data,
raptor_xml_element *xml_element)
{
raptor_qname* qname = raptor_xml_element_get_name(xml_element);
int nb_attributes = raptor_xml_element_get_attributes_count(xml_element);
raptor_qname** attrs = raptor_xml_element_get_attributes(xml_element);
unsigned char* localname = raptor_qname_to_counted_name(qname, NULL);
const raptor_namespace* qname_ns = raptor_qname_get_namespace(qname);
int nb_namespaces = 0;
const char** namespaces = NULL;
int nb_defaulted = 0;
char** attr = NULL;
int i;
const char* ns_name = NULL;
const char* ns_uri = NULL;
if(nb_attributes > 0) {
/* Everything written into 'attr' is a shared pointer into
* xml_element or contained objects - qnames, namespaces, uris
* and values
*/
attr = (char**)malloc(sizeof(char*) * (1 + (nb_attributes * 5)));
for(i = 0; i < nb_attributes; i++) {
const raptor_namespace* attr_ns = attrs[i]->nspace;
char** attri = &attr[5 * i];
/* 5 tuple: (localname, prefix, URI, value, end) */
attri[0] = (char*)attrs[i]->local_name;
attri[1] = attr_ns ? (char*)attr_ns->prefix : NULL;
attri[2] = attr_ns ? (char*)raptor_uri_as_string(attr_ns->uri) : NULL;
attri[3] = (char*)attrs[i]->value;
attri[4] = attri[3] + attrs[i]->value_length;
}
attr[5 * i] = NULL;
}
/*
* @ctx: the user data (XML parser context)
* @localname: the local name of the element
* @prefix: the element namespace prefix if available
* @URI: the element namespace name if available
* @nb_namespaces: number of namespace definitions on that node
* @namespaces: pointer to the array of prefix/URI pairs namespace definitions
* @nb_attributes: the number of attributes on that node
* @nb_defaulted: the number of defaulted attributes. The defaulted
* ones are at the end of the array
* @attributes: pointer to the array of (localname/prefix/URI/value/end)
* attribute values.
*/
if(qname_ns) {
ns_name = (const char*)raptor_namespace_get_prefix(qname_ns);
ns_uri = (const char*)raptor_uri_as_string(qname_ns->uri);
}
start_element(user_data, (const char*)localname,
ns_name,
ns_uri,
nb_namespaces,
(const char**)namespaces,
nb_attributes,
nb_defaulted,
(const char**)attr);
if(attr)
free(attr);
raptor_free_memory(localname);
}