summaryrefslogtreecommitdiffstats
path: root/librdfa/rdfa.c
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-15 05:40:05 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-15 05:40:05 +0000
commit4038ab95a094b363f1748f3dcb51511a1217475d (patch)
tree7f393d66a783f91ddd263c78d681e485cf4f45ca /librdfa/rdfa.c
parentInitial commit. (diff)
downloadraptor2-4038ab95a094b363f1748f3dcb51511a1217475d.tar.xz
raptor2-4038ab95a094b363f1748f3dcb51511a1217475d.zip
Adding upstream version 2.0.16.upstream/2.0.16upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'librdfa/rdfa.c')
-rw-r--r--librdfa/rdfa.c1552
1 files changed, 1552 insertions, 0 deletions
diff --git a/librdfa/rdfa.c b/librdfa/rdfa.c
new file mode 100644
index 0000000..6dadbe0
--- /dev/null
+++ b/librdfa/rdfa.c
@@ -0,0 +1,1552 @@
+/**
+ * Copyright 2008-2011 Digital Bazaar, Inc.
+ *
+ * This file is part of librdfa.
+ *
+ * librdfa is Free Software, and can be licensed under any of the
+ * following three licenses:
+ *
+ * 1. GNU Lesser General Public License (LGPL) V2.1 or any
+ * newer version
+ * 2. GNU General Public License (GPL) V2 or any newer version
+ * 3. Apache License, V2.0 or any newer version
+ *
+ * You may not use this file except in compliance with at least one of
+ * the above three licenses.
+ *
+ * See LICENSE-* at the top of this software distribution for more
+ * information regarding the details of each license.
+ *
+ * The librdfa library is the Fastest RDFa Parser in the Universe. It is
+ * a stream parser, meaning that it takes an XML data as input and spits
+ * out RDF triples as it comes across them in the stream. Due to this
+ * processing approach, librdfa has a very, very small memory footprint.
+ * It is also very fast and can operate on hundreds of gigabytes of XML
+ * data without breaking a sweat.
+ *
+ * Usage:
+ *
+ * rdfacontext* context = rdfa_create_context(BASE_URI);
+ * context->callback_data = your_user_data;
+ * rdfa_set_default_graph_triple_handler(context, &default_graph_triple);
+ * rdfa_set_processor_graph_triple_handler(context, &processor_graph_triple);
+ * rdfa_set_buffer_filler(context, &fill_buffer);
+ * rdfa_parse(context);
+ * rdfa_free_context(context);
+ *
+ * @author Manu Sporny
+ */
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#ifdef HAVE_STRINGS_H
+# include <strings.h>
+#endif
+#include <ctype.h>
+#include <libxml/SAX2.h>
+#include "rdfa_utils.h"
+#include "rdfa.h"
+#include "strtok_r.h"
+
+#define READ_BUFFER_SIZE 4096
+#define RDFA_DOCTYPE_STRING_LENGTH 103
+
+/**
+ * Read the head of the XHTML document and determines the base IRI for
+ * the document.
+ *
+ * @param context the current working context.
+ * @param working_buffer the current working buffer.
+ * @param wb_allocated the number of bytes that have been allocated to
+ * the working buffer.
+ *
+ * @return the size of the data available in the working buffer.
+ */
+static size_t rdfa_init_base(
+ rdfacontext* context, char** working_buffer, size_t* working_buffer_size,
+ char* temp_buffer, size_t bytes_read)
+{
+ char* head_end = NULL;
+ size_t offset = context->wb_position;
+ size_t needed_size = 0;
+
+ if((offset + bytes_read) > *working_buffer_size)
+ {
+ needed_size = (offset + bytes_read) - *working_buffer_size;
+ }
+
+ /* search for the end of <head>, stop if <head> was found */
+
+ /* extend the working buffer size */
+ if(needed_size > 0)
+ {
+ size_t temp_buffer_size = sizeof(char) * READ_BUFFER_SIZE;
+ if((size_t)needed_size > temp_buffer_size)
+ temp_buffer_size += needed_size;
+
+ *working_buffer_size += temp_buffer_size;
+ /* +1 for NUL at end, to allow strstr() etc. to work */
+ *working_buffer = (char*)realloc(*working_buffer, *working_buffer_size + 1);
+ }
+
+ /* append to the working buffer */
+ memmove(*working_buffer + offset, temp_buffer, bytes_read);
+ /* ensure the buffer is a NUL-terminated string */
+ *(*working_buffer + offset + bytes_read) = '\0';
+
+ /* Sniff the beginning of the document for any document information */
+ if(strstr(*working_buffer, "-//W3C//DTD XHTML+RDFa 1.0//EN") != NULL)
+ {
+ context->host_language = HOST_LANGUAGE_XHTML1;
+ context->rdfa_version = RDFA_VERSION_1_0;
+ }
+ else if(strstr(*working_buffer, "-//W3C//DTD XHTML+RDFa 1.1//EN") != NULL)
+ {
+ context->host_language = HOST_LANGUAGE_XHTML1;
+ context->rdfa_version = RDFA_VERSION_1_1;
+ }
+ else if(strstr(*working_buffer, "<html") != NULL)
+ {
+ context->host_language = HOST_LANGUAGE_HTML;
+ context->rdfa_version = RDFA_VERSION_1_1;
+ }
+ else
+ {
+ context->host_language = HOST_LANGUAGE_XML1;
+ context->rdfa_version = RDFA_VERSION_1_1;
+ }
+
+#ifdef LIBRDFA_IN_RAPTOR
+ if(context->raptor_rdfa_version == 10) {
+ context->host_language = HOST_LANGUAGE_XHTML1;
+ context->rdfa_version = RDFA_VERSION_1_0;
+ } else if(context->raptor_rdfa_version == 11)
+ context->rdfa_version = RDFA_VERSION_1_1;
+#endif
+
+ /* search for the end of </head> in */
+ head_end = strstr(*working_buffer, "</head>");
+ if(head_end == NULL)
+ head_end = strstr(*working_buffer, "</HEAD>");
+
+ context->wb_position += bytes_read;
+
+ if(head_end == NULL)
+ return bytes_read;
+
+ /* if </head> was found, search for <base and extract the base URI */
+ if(head_end != NULL)
+ {
+ char* base_start = strstr(*working_buffer, "<base ");
+ char* href_start = NULL;
+ if(base_start == NULL)
+ base_start = strstr(*working_buffer, "<BASE ");
+ if(base_start != NULL)
+ href_start = strstr(base_start, "href=");
+
+ if(href_start != NULL)
+ {
+ char sep = href_start[5];
+ char* uri_start = href_start + 6;
+ char* uri_end = strchr(uri_start, sep);
+
+ if(uri_end != NULL)
+ {
+ if(*uri_start != sep)
+ {
+ size_t uri_size = uri_end - uri_start;
+ char* temp_uri = (char*)malloc(sizeof(char) * uri_size + 1);
+ char* cleaned_base;
+ strncpy(temp_uri, uri_start, uri_size);
+ temp_uri[uri_size] = '\0';
+
+ /* TODO: This isn't in the processing rules, should it
+ * be? Setting current_object_resource will make
+ * sure that the BASE element is inherited by all
+ * subcontexts. */
+ cleaned_base = rdfa_iri_get_base(temp_uri);
+ context->current_object_resource =
+ rdfa_replace_string(
+ context->current_object_resource, cleaned_base);
+
+ /* clean up the base context */
+ context->base =
+ rdfa_replace_string(context->base, cleaned_base);
+ free(cleaned_base);
+ free(temp_uri);
+ }
+ }
+ }
+ }
+
+ return bytes_read;
+}
+
+#ifdef LIBRDFA_IN_RAPTOR
+static int
+raptor_nspace_compare(const void *a, const void *b)
+{
+ raptor_namespace* ns_a=*(raptor_namespace**)a;
+ raptor_namespace* ns_b=*(raptor_namespace**)b;
+ if(!ns_a->prefix)
+ return 1;
+ else if(!ns_b->prefix)
+ return -1;
+ else
+ return strcmp((const char*)ns_b->prefix, (const char*)ns_a->prefix);
+}
+#endif
+
+/**
+ * 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
+ const 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 = (const char*)raptor_namespace_get_prefix(ns);
+ if(!umap_key)
+ umap_key=(const 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;
+ size_t literal_text_length;
+
+ 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);
+ snprintf(value, value_length, "%s", attributes[ci + 3]);
+
+ literal_text_length = strlen(attr) + value_length + 4;
+ literal_text = (char*)malloc(literal_text_length + 1);
+ snprintf(literal_text, literal_text_length, " %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 character_data(
+ void *parser_context, const xmlChar *s, int len)
+{
+ /*xmlParserCtxtPtr parser = (xmlParserCtxtPtr)parser_context;*/
+ rdfalist* context_stack =
+ (rdfalist*)((rdfacontext*)parser_context)->context_stack;
+ rdfacontext* context = (rdfacontext*)
+ context_stack->items[context_stack->num_items - 1]->data;
+
+ char *buffer = (char*)malloc(len + 1);
+ memset(buffer, 0, len + 1);
+ memcpy(buffer, s, len);
+
+ /* append the text to the current context's plain literal */
+ if(context->plain_literal == NULL)
+ {
+ context->plain_literal =
+ rdfa_replace_string(context->plain_literal, buffer);
+ context->plain_literal_size = len;
+ }
+ else
+ {
+ context->plain_literal = rdfa_n_append_string(
+ context->plain_literal,
+ &context->plain_literal_size, buffer, len);
+ }
+
+ /* append the text to the current context's XML literal */
+ if(context->xml_literal == NULL)
+ {
+ context->xml_literal =
+ rdfa_replace_string(context->xml_literal, buffer);
+ context->xml_literal_size = len;
+ }
+ else
+ {
+ context->xml_literal = rdfa_n_append_string(
+ context->xml_literal, &context->xml_literal_size, buffer, len);
+ }
+
+ /*printf("plain_literal: %s\n", context->plain_literal);*/
+ /*printf("xml_literal: %s\n", context->xml_literal);*/
+
+ free(buffer);
+}
+
+static void end_element(void* parser_context, const char* name,
+ const char* prefix,const xmlChar* URI)
+{
+ /*xmlParserCtxtPtr parser = (xmlParserCtxtPtr)parser_context;*/
+ rdfalist* context_stack =
+ (rdfalist*)((rdfacontext*)parser_context)->context_stack;
+ rdfacontext* context = (rdfacontext*)rdfa_pop_item(context_stack);
+ rdfacontext* parent_context = (rdfacontext*)
+ context_stack->items[context_stack->num_items - 1]->data;
+
+ /* append the text to the current context's XML literal */
+ size_t name_len = strlen(name);
+ char* buffer = (char*)malloc(name_len + 3 + 1);
+
+#if defined(DEBUG) && DEBUG > 0
+ printf("DEBUG: </%s>\n", name);
+ printf("context->local_list_mappings (start of end_element): ");
+ rdfa_print_mapping(context->local_list_mappings,
+ (print_mapping_value_fp)rdfa_print_triple_list);
+#endif
+
+ buffer[0] = '<';
+ buffer[1] = '/';
+ memcpy(buffer + 2, name, name_len);
+ buffer[name_len + 2] = '>';
+ buffer[name_len + 3] = '\0';
+ if(context->xml_literal == NULL)
+ {
+ context->xml_literal =
+ rdfa_replace_string(context->xml_literal, buffer);
+ context->xml_literal_size = strlen(buffer);
+ }
+ else
+ {
+ context->xml_literal = rdfa_n_append_string(
+ context->xml_literal, &context->xml_literal_size,
+ buffer, strlen(buffer));
+ }
+ free(buffer);
+
+ /* 9. The next step of the iteration is to establish any
+ * [current object literal]; */
+
+ /* generate the complete object literal triples */
+ if(context->property != NULL)
+ {
+ /* save the current xml literal */
+ char* saved_xml_literal = context->xml_literal;
+ char* content_start = NULL;
+ char* content_end = NULL;
+
+ /* ensure to mark only the inner-content of the XML node for
+ * processing the object literal. */
+ buffer = NULL;
+
+ if(context->xml_literal != NULL)
+ {
+ /* get the data between the first tag and the last tag */
+ content_start = strchr(context->xml_literal, '>');
+ content_end = strrchr(context->xml_literal, '<');
+
+ if((content_start != NULL) && (content_end != NULL))
+ {
+ /* set content end to null terminator */
+ context->xml_literal = ++content_start;
+ *content_end = '\0';
+ }
+ }
+
+ /* update the plain literal if the XML Literal is an empty string */
+ if(context->xml_literal != NULL && strlen(context->xml_literal) == 0)
+ {
+ context->plain_literal =
+ rdfa_replace_string(context->plain_literal, "");
+ }
+
+ /* process data between first tag and last tag
+ * this needs the xml literal to be null terminated */
+ if(context->rdfa_version == RDFA_VERSION_1_0)
+ {
+ rdfa_complete_object_literal_triples(context);
+ }
+ else
+ {
+ rdfa_complete_current_property_value_triples(context);
+ }
+
+ if(content_end != NULL)
+ {
+ /* set content end back */
+ *content_end = '<';
+ }
+
+ if(saved_xml_literal != NULL)
+ {
+ /* restore xml literal */
+ context->xml_literal = saved_xml_literal;
+ }
+ }
+
+ /*printf(context->plain_literal);*/
+
+ if(parent_context != NULL) {
+ /* append the XML literal and plain text literals to the parent
+ * literals */
+ if(context->xml_literal != NULL)
+ {
+ if(parent_context->xml_literal == NULL)
+ {
+ parent_context->xml_literal =
+ rdfa_replace_string(
+ parent_context->xml_literal, context->xml_literal);
+ parent_context->xml_literal_size = context->xml_literal_size;
+ }
+ else
+ {
+ parent_context->xml_literal =
+ rdfa_n_append_string(
+ parent_context->xml_literal,
+ &parent_context->xml_literal_size,
+ context->xml_literal, context->xml_literal_size);
+ }
+
+ /* if there is an XML literal, there is probably a plain literal */
+ if(context->plain_literal != NULL)
+ {
+ if(parent_context->plain_literal == NULL)
+ {
+ parent_context->plain_literal =
+ rdfa_replace_string(
+ parent_context->plain_literal, context->plain_literal);
+ parent_context->plain_literal_size =
+ context->plain_literal_size;
+ }
+ else
+ {
+ parent_context->plain_literal =
+ rdfa_n_append_string(
+ parent_context->plain_literal,
+ &parent_context->plain_literal_size,
+ context->plain_literal,
+ context->plain_literal_size);
+ }
+ }
+ }
+
+ /* preserve the bnode count by copying it to the parent_context */
+ parent_context->bnode_count = context->bnode_count;
+ parent_context->underscore_colon_bnode_name = \
+ rdfa_replace_string(parent_context->underscore_colon_bnode_name,
+ context->underscore_colon_bnode_name);
+ }
+
+ /* 10. If the [ skip element ] flag is 'false', and [ new subject ]
+ * was set to a non-null value, then any [ incomplete triple ]s
+ * within the current context should be completed: */
+ if((context->skip_element == 0) && (context->new_subject != NULL))
+ {
+ rdfa_complete_incomplete_triples(context);
+ }
+
+ /* 14. Once all the child elements have been traversed, list triples are
+ * generated, if necessary. */
+ if(context->rdfa_version == RDFA_VERSION_1_1 && (context->new_subject != NULL))
+ {
+ rdfa_complete_list_triples(context);
+
+ if(parent_context != NULL)
+ {
+ /* copy the current mapping to the parent mapping */
+ rdfa_free_mapping(parent_context->local_list_mappings,
+ (free_mapping_value_fp)rdfa_free_list);
+ parent_context->local_list_mappings = rdfa_copy_mapping(
+ (void**)context->local_list_mappings,
+ (copy_mapping_value_fp)rdfa_replace_list);
+
+#if defined(DEBUG) && DEBUG > 0
+ printf("parent_context->local_list_mappings (after copy): ");
+ rdfa_print_mapping(context->local_list_mappings,
+ (print_mapping_value_fp)rdfa_print_triple_list);
+#endif
+ rdfa_free_mapping(context->local_list_mappings,
+ (free_mapping_value_fp)rdfa_free_list);
+ context->local_list_mappings = NULL;
+ }
+ }
+
+ /* free the context */
+ rdfa_free_context(context);
+
+#if defined(DEBUG) && DEBUG > 0
+ printf("-------------------------------------------------------------\n");
+#endif
+}
+
+void rdfa_set_default_graph_triple_handler(
+ rdfacontext* context, triple_handler_fp th)
+{
+ context->default_graph_triple_callback = th;
+}
+
+void rdfa_set_processor_graph_triple_handler(
+ rdfacontext* context, triple_handler_fp th)
+{
+ context->processor_graph_triple_callback = th;
+}
+
+void rdfa_set_buffer_filler(rdfacontext* context, buffer_filler_fp bf)
+{
+ context->buffer_filler_callback = bf;
+}
+
+#ifdef LIBRDFA_IN_RAPTOR
+/* Raptor reports its errors a different way */
+#else
+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);
+}
+#endif
+
+#ifdef LIBRDFA_IN_RAPTOR
+
+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);
+}
+
+static void raptor_rdfa_end_element(void *user_data,
+ raptor_xml_element* xml_element)
+{
+ raptor_qname* qname = raptor_xml_element_get_name(xml_element);
+ unsigned char* localname = raptor_qname_to_counted_name(qname, NULL);
+ const raptor_namespace* qname_ns = raptor_qname_get_namespace(qname);
+
+ if(qname_ns)
+ end_element(user_data, (const char*)localname,
+ (const char*)qname_ns->prefix,
+ (const xmlChar*)raptor_uri_as_string(qname_ns->uri));
+ else
+ end_element(user_data, (const char*)localname, NULL, NULL);
+
+ raptor_free_memory(localname);
+}
+
+static void raptor_rdfa_character_data(void *user_data,
+ raptor_xml_element* xml_element,
+ const unsigned char *s, int len)
+{
+ character_data(user_data, (const xmlChar *)s, len);
+}
+
+static void raptor_rdfa_namespace_handler(void *user_data,
+ raptor_namespace* nspace)
+{
+ rdfacontext* context = (rdfacontext*)user_data;
+
+ if(context->namespace_handler)
+ (*context->namespace_handler)(context->namespace_handler_user_data,
+ nspace);
+}
+
+#endif
+
+int rdfa_parse_start(rdfacontext* context)
+{
+ /* create the buffers and expat parser */
+ int rval = RDFA_PARSE_SUCCESS;
+
+ context->wb_allocated = sizeof(char) * READ_BUFFER_SIZE;
+ /* +1 for NUL at end, to allow strstr() etc. to work
+ * malloc - only the first char needs to be NUL */
+ context->working_buffer = (char*)malloc(context->wb_allocated + 1);
+ *context->working_buffer = '\0';
+ context->done = 0;
+ context->context_stack = rdfa_create_list(32);
+
+ /* initialize the context stack */
+ rdfa_push_item(context->context_stack, context, RDFALIST_FLAG_CONTEXT);
+
+#ifdef LIBRDFA_IN_RAPTOR
+ context->sax2 = raptor_new_sax2(context->world, context->locator,
+ context);
+#else
+ /* init libxml2 */
+ xmlInitParser();
+#endif
+
+ /* set up the context stack */
+#ifdef LIBRDFA_IN_RAPTOR
+ raptor_sax2_set_start_element_handler(context->sax2,
+ raptor_rdfa_start_element);
+ raptor_sax2_set_end_element_handler(context->sax2,
+ raptor_rdfa_end_element);
+ raptor_sax2_set_characters_handler(context->sax2,
+ raptor_rdfa_character_data);
+ raptor_sax2_set_namespace_handler(context->sax2,
+ raptor_rdfa_namespace_handler);
+#endif
+
+ rdfa_init_context(context);
+
+#ifdef LIBRDFA_IN_RAPTOR
+ context->base_uri = raptor_new_uri(context->sax2->world,
+ (const unsigned char*)context->base);
+ raptor_sax2_parse_start(context->sax2, context->base_uri);
+#endif
+
+ return rval;
+}
+
+int rdfa_parse_chunk(rdfacontext* context, char* data, size_t wblen, int done)
+{
+#ifdef LIBRDFA_IN_RAPTOR
+#else
+ xmlSAXHandler handler;
+ xmlParserCtxtPtr parser;
+#endif
+
+ /* it is an error to call this before rdfa_parse_start() */
+ if(context->done)
+ {
+ return RDFA_PARSE_FAILED;
+ }
+
+ if(!context->preread)
+ {
+ /* search for the <base> tag and use the href contained therein to
+ * set the parsing context. */
+ context->wb_preread = rdfa_init_base(context,
+ &context->working_buffer, &context->wb_allocated, data, wblen);
+
+ /* continue looking if in first 131072 bytes of data */
+ if(!context->base && context->wb_preread < (1<<17))
+ return RDFA_PARSE_SUCCESS;
+
+#ifdef LIBRDFA_IN_RAPTOR
+ /* term mappings are needed before SAX2 parsing */
+ rdfa_setup_initial_context(context);
+
+ if(raptor_sax2_parse_chunk(context->sax2,
+ (const unsigned char*)context->working_buffer,
+ context->wb_position, done))
+ {
+ return RDFA_PARSE_FAILED;
+ }
+#else
+ /* create the SAX2 handler structure */
+ memset(&handler, 0, sizeof(xmlSAXHandler));
+ handler.initialized = XML_SAX2_MAGIC;
+ handler.startElementNs = (startElementNsSAX2Func)start_element;
+ handler.endElementNs = (endElementNsSAX2Func)end_element;
+ handler.characters = (charactersSAXFunc)character_data;
+ handler.error = (errorSAXFunc)rdfa_report_error;
+
+ /* create a push-based parser */
+ parser = xmlCreatePushParserCtxt(
+ &handler, context, (const char*)context->working_buffer,
+ context->wb_position, NULL);
+
+ /* ensure that entity substitution is turned on by default */
+ xmlSubstituteEntitiesDefault(1);
+
+ context->parser = parser;
+
+ rdfa_setup_initial_context(context);
+#endif
+
+ context->preread = 1;
+
+ return RDFA_PARSE_SUCCESS;
+ }
+
+ /* otherwise just parse the block passed in */
+#ifdef LIBRDFA_IN_RAPTOR
+ if(raptor_sax2_parse_chunk(context->sax2,
+ (const unsigned char*)data, wblen, done))
+ {
+ return RDFA_PARSE_FAILED;
+ }
+#else
+ if(xmlParseChunk(context->parser, data, wblen, done))
+ {
+ return RDFA_PARSE_FAILED;
+ }
+#endif
+
+ return RDFA_PARSE_SUCCESS;
+}
+
+void rdfa_parse_end(rdfacontext* context)
+{
+ /* free context stack */
+ rdfa_free_context_stack(context);
+
+ /* Free the expat parser and the like */
+#ifdef LIBRDFA_IN_RAPTOR
+ if(context->base_uri)
+ raptor_free_uri(context->base_uri);
+ raptor_free_sax2(context->sax2);
+ context->sax2=NULL;
+#else
+ /* free parser */
+ xmlFreeParserCtxt(context->parser);
+ xmlCleanupParser();
+#endif
+}
+
+char* rdfa_get_buffer(rdfacontext* context, size_t* blen)
+{
+ *blen = context->wb_allocated;
+ return context->working_buffer;
+}
+
+int rdfa_parse_buffer(rdfacontext* context, size_t bytes)
+{
+ int rval;
+ int done;
+ done = (bytes == 0);
+ rval = rdfa_parse_chunk(context, context->working_buffer, bytes, done);
+ context->done = done;
+ return rval;
+}
+
+int rdfa_parse(rdfacontext* context)
+{
+ int rval;
+
+ rval = rdfa_parse_start(context);
+ if(rval != RDFA_PARSE_SUCCESS)
+ {
+ context->done = 1;
+ return rval;
+ }
+
+ do
+ {
+ size_t wblen;
+ int done;
+
+ wblen = context->buffer_filler_callback(
+ context->working_buffer, context->wb_allocated,
+ context->callback_data);
+ done = (wblen == 0);
+
+ rval = rdfa_parse_chunk(context, context->working_buffer, wblen, done);
+ context->done=done;
+ }
+ while(!context->done && rval == RDFA_PARSE_SUCCESS);
+
+ rdfa_parse_end(context);
+
+ return rval;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-25 11:42:49 +0000