Adding upstream version 2.0.16.upstream/2.0.16upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 591 insertions, 0 deletions

diff --git a/librdfa/context.c b/librdfa/context.c
new file mode 100644
index 0000000..fca5b07
--- /dev/null
+++ b/librdfa/context.c
@@ -0,0 +1,591 @@
+/**
+ * Copyright 2008-2012 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.
+ */
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include <string.h>
+#include "rdfa_utils.h"
+#include "rdfa.h"
+
+rdfacontext* rdfa_create_context(const char* base)
+{
+   rdfacontext* rval = NULL;
+   size_t base_length = strlen(base);
+
+   /* if the base isn't specified, don't create a context */
+   if(base_length > 0)
+   {
+      char* cleaned_base;
+
+      /* malloc and init whole context to NULL */
+      rval = (rdfacontext*)malloc(sizeof(rdfacontext));
+      if(!rval)
+         return NULL;
+
+      memset(rval, 0, sizeof(rdfacontext));
+
+      /* clean and initialize base */
+      cleaned_base = rdfa_iri_get_base(base);
+      rval->base = rdfa_replace_string(rval->base, cleaned_base);
+      free(cleaned_base);
+   }
+   else
+   {
+#ifdef LIBRDFA_IN_RAPTOR
+#else
+      printf("librdfa error: Failed to create a parsing context, "
+         "base IRI was not specified!\n");
+#endif
+   }
+
+   return rval;
+}
+
+void rdfa_init_context(rdfacontext* context)
+{
+   /* assume the RDFa processing rules are RDFa 1.1 unless otherwise specified */
+   context->rdfa_version = RDFA_VERSION_1_1;
+
+   /* assume the default host language is XML1 */
+   context->host_language = HOST_LANGUAGE_XML1;
+
+   /* the [parent subject] is set to the [base] value; */
+   context->parent_subject = NULL;
+   if(context->base != NULL)
+   {
+      char* cleaned_base = rdfa_iri_get_base(context->base);
+      context->parent_subject =
+         rdfa_replace_string(context->parent_subject, cleaned_base);
+      free(cleaned_base);
+   }
+
+   /* the [parent object] is set to null; */
+   context->parent_object = NULL;
+
+#ifdef LIBRDFA_IN_RAPTOR
+#else
+   /* the [list of URI mappings] is cleared; */
+   context->uri_mappings = rdfa_create_mapping(MAX_URI_MAPPINGS);
+#endif
+
+   /* the [list of incomplete triples] is cleared; */
+   context->incomplete_triples = rdfa_create_list(3);
+
+   /* the [language] is set to null. */
+   context->language = NULL;
+
+   /* set the [current object resource] to null; */
+   context->current_object_resource = NULL;
+
+   /* the list of term mappings is set to null
+    * (or a list defined in the initial context of the Host Language). */
+   context->term_mappings = rdfa_create_mapping(MAX_TERM_MAPPINGS);
+
+   /* the maximum number of list mappings */
+   context->list_mappings = rdfa_create_mapping(MAX_LIST_MAPPINGS);
+
+   /* the maximum number of local list mappings */
+   context->local_list_mappings =
+      rdfa_create_mapping(MAX_LOCAL_LIST_MAPPINGS);
+
+   /* the default vocabulary is set to null
+    * (or a IRI defined in the initial context of the Host Language). */
+   context->default_vocabulary = NULL;
+
+   /* whether or not the @inlist attribute is present on the current element */
+   context->inlist_present = 0;
+
+   /* whether or not the @rel attribute is present on the current element */
+   context->rel_present = 0;
+
+   /* whether or not the @rev attribute is present on the current element */
+   context->rev_present = 0;
+
+   /* 1. First, the local values are initialized, as follows:
+    *
+    * * the [recurse] flag is set to 'true'; */
+   context->recurse = 1;
+
+   /* * the [skip element] flag is set to 'false'; */
+   context->skip_element = 0;
+
+   /* * [new subject] is set to null; */
+   context->new_subject = NULL;
+
+   /* * [current object resource] is set to null; */
+   context->current_object_resource = NULL;
+
+   /* * the [local list of URI mappings] is set to the list of URI
+    *   mappings from the [evaluation context];
+    *   NOTE: This step is done in rdfa_create_new_element_context() */
+
+   /* FIXME: Initialize the term mappings and URI mappings based on Host Language */
+
+   /* * the [local list of incomplete triples] is set to null; */
+   context->local_incomplete_triples = rdfa_create_list(3);
+
+   /* * the [current language] value is set to the [language] value
+    *   from the [evaluation context].
+    *   NOTE: This step is done in rdfa_create_new_element_context() */
+}
+
+#ifdef LIBRDFA_IN_RAPTOR
+#define DECLARE_URI_MAPPING(context, prefix, value)                     \
+do {                                                                    \
+    raptor_namespace_stack* nstack = &context->sax2->namespaces;        \
+    raptor_namespace* ns = raptor_new_namespace(nstack,                 \
+      (const unsigned char *)prefix, (const unsigned char*)value, 0);   \
+    raptor_namespaces_start_namespace(nstack, ns);                      \
+    } while(0)
+#else
+#define DECLARE_URI_MAPPING(context, prefix, value)                     \
+  rdfa_update_mapping(context->uri_mappings, prefix, value,             \
+                      (update_mapping_value_fp)rdfa_replace_string)
+#endif
+
+void rdfa_setup_initial_context(rdfacontext* context)
+{
+#ifdef LIBRDFA_IN_RAPTOR
+#else
+   char* key = NULL;
+   void* value = NULL;
+   void** mptr = context->uri_mappings;
+#endif
+
+   /* Setup the base RDFa 1.1 prefix and term mappings */
+   if(context->rdfa_version == RDFA_VERSION_1_1)
+   {
+      /* Setup the base RDFa 1.1 prefix mappings */
+      DECLARE_URI_MAPPING(context,
+         "grddl", "http://www.w3.org/2003/g/data-view#");
+      DECLARE_URI_MAPPING(context,
+         "ma", "http://www.w3.org/ns/ma-ont#");
+      DECLARE_URI_MAPPING(context,
+         "owl", "http://www.w3.org/2002/07/owl#");
+      DECLARE_URI_MAPPING(context,
+         "rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#");
+      DECLARE_URI_MAPPING(context,
+         "rdfa", "http://www.w3.org/ns/rdfa#");
+      DECLARE_URI_MAPPING(context,
+         "rdfs", "http://www.w3.org/2000/01/rdf-schema#");
+      DECLARE_URI_MAPPING(context,
+         "rif", "http://www.w3.org/2007/rif#");
+      DECLARE_URI_MAPPING(context,
+         "skos", "http://www.w3.org/2004/02/skos/core#");
+      DECLARE_URI_MAPPING(context,
+         "skosxl", "http://www.w3.org/2008/05/skos-xl#");
+      DECLARE_URI_MAPPING(context,
+         "wdr", "http://www.w3.org/2007/05/powder#");
+      DECLARE_URI_MAPPING(context,
+         "void", "http://rdfs.org/ns/void#");
+      DECLARE_URI_MAPPING(context,
+         "wdrs", "http://www.w3.org/2007/05/powder-s#");
+      DECLARE_URI_MAPPING(context,
+         "xhv", "http://www.w3.org/1999/xhtml/vocab#");
+      DECLARE_URI_MAPPING(context,
+         "xml", "http://www.w3.org/XML/1998/namespace");
+      DECLARE_URI_MAPPING(context,
+         "xsd", "http://www.w3.org/2001/XMLSchema#");
+      DECLARE_URI_MAPPING(context,
+         "cc", "http://creativecommons.org/ns#");
+      DECLARE_URI_MAPPING(context,
+         "ctag", "http://commontag.org/ns#");
+      DECLARE_URI_MAPPING(context,
+         "dc", "http://purl.org/dc/terms/");
+      DECLARE_URI_MAPPING(context,
+         "dcterms", "http://purl.org/dc/terms/");
+      DECLARE_URI_MAPPING(context,
+         "foaf", "http://xmlns.com/foaf/0.1/");
+      DECLARE_URI_MAPPING(context,
+         "gr", "http://purl.org/goodrelations/v1#");
+      DECLARE_URI_MAPPING(context,
+         "ical", "http://www.w3.org/2002/12/cal/icaltzd#");
+      DECLARE_URI_MAPPING(context,
+         "og", "http://ogp.me/ns#");
+      DECLARE_URI_MAPPING(context,
+         "rev", "http://purl.org/stuff/rev#");
+      DECLARE_URI_MAPPING(context,
+         "sioc", "http://rdfs.org/sioc/ns#");
+      DECLARE_URI_MAPPING(context,
+         "v", "http://rdf.data-vocabulary.org/#");
+      DECLARE_URI_MAPPING(context,
+         "vcard", "http://www.w3.org/2006/vcard/ns#");
+      DECLARE_URI_MAPPING(context,
+         "schema", "http://schema.org/");
+
+      /* Setup the base RDFa 1.1 term mappings */
+      rdfa_update_mapping(context->term_mappings,
+         "describedby", "http://www.w3.org/2007/05/powder-s#describedby",
+         (update_mapping_value_fp)rdfa_replace_string);
+      rdfa_update_mapping(context->term_mappings,
+         "license", "http://www.w3.org/1999/xhtml/vocab#license",
+         (update_mapping_value_fp)rdfa_replace_string);
+      rdfa_update_mapping(context->term_mappings,
+         "role", "http://www.w3.org/1999/xhtml/vocab#role",
+         (update_mapping_value_fp)rdfa_replace_string);
+   }
+
+   /* Setup the term mappings for XHTML1 */
+   if(context->host_language == HOST_LANGUAGE_XHTML1)
+   {
+      rdfa_update_mapping(context->term_mappings,
+         "alternate", "http://www.w3.org/1999/xhtml/vocab#alternate",
+         (update_mapping_value_fp)rdfa_replace_string);
+      rdfa_update_mapping(context->term_mappings,
+         "appendix", "http://www.w3.org/1999/xhtml/vocab#appendix",
+         (update_mapping_value_fp)rdfa_replace_string);
+      rdfa_update_mapping(context->term_mappings,
+         "cite", "http://www.w3.org/1999/xhtml/vocab#cite",
+         (update_mapping_value_fp)rdfa_replace_string);
+      rdfa_update_mapping(context->term_mappings,
+         "bookmark", "http://www.w3.org/1999/xhtml/vocab#bookmark",
+         (update_mapping_value_fp)rdfa_replace_string);
+      rdfa_update_mapping(context->term_mappings,
+         "contents", "http://www.w3.org/1999/xhtml/vocab#contents",
+         (update_mapping_value_fp)rdfa_replace_string);
+      rdfa_update_mapping(context->term_mappings,
+         "chapter", "http://www.w3.org/1999/xhtml/vocab#chapter",
+         (update_mapping_value_fp)rdfa_replace_string);
+      rdfa_update_mapping(context->term_mappings,
+         "copyright", "http://www.w3.org/1999/xhtml/vocab#copyright",
+         (update_mapping_value_fp)rdfa_replace_string);
+      rdfa_update_mapping(context->term_mappings,
+         "first", "http://www.w3.org/1999/xhtml/vocab#first",
+         (update_mapping_value_fp)rdfa_replace_string);
+      rdfa_update_mapping(context->term_mappings,
+         "glossary", "http://www.w3.org/1999/xhtml/vocab#glossary",
+         (update_mapping_value_fp)rdfa_replace_string);
+      rdfa_update_mapping(context->term_mappings,
+         "help", "http://www.w3.org/1999/xhtml/vocab#help",
+         (update_mapping_value_fp)rdfa_replace_string);
+      rdfa_update_mapping(context->term_mappings,
+         "icon", "http://www.w3.org/1999/xhtml/vocab#icon",
+         (update_mapping_value_fp)rdfa_replace_string);
+      rdfa_update_mapping(context->term_mappings,
+         "index", "http://www.w3.org/1999/xhtml/vocab#index",
+         (update_mapping_value_fp)rdfa_replace_string);
+      rdfa_update_mapping(context->term_mappings,
+         "last", "http://www.w3.org/1999/xhtml/vocab#last",
+         (update_mapping_value_fp)rdfa_replace_string);
+      rdfa_update_mapping(context->term_mappings,
+         "license", "http://www.w3.org/1999/xhtml/vocab#license",
+         (update_mapping_value_fp)rdfa_replace_string);
+      rdfa_update_mapping(context->term_mappings,
+         "meta", "http://www.w3.org/1999/xhtml/vocab#meta",
+         (update_mapping_value_fp)rdfa_replace_string);
+      rdfa_update_mapping(context->term_mappings,
+         "next", "http://www.w3.org/1999/xhtml/vocab#next",
+         (update_mapping_value_fp)rdfa_replace_string);
+      rdfa_update_mapping(context->term_mappings,
+         "prev", "http://www.w3.org/1999/xhtml/vocab#prev",
+         (update_mapping_value_fp)rdfa_replace_string);
+      rdfa_update_mapping(context->term_mappings,
+         "previous", "http://www.w3.org/1999/xhtml/vocab#previous",
+         (update_mapping_value_fp)rdfa_replace_string);
+      rdfa_update_mapping(context->term_mappings,
+         "section", "http://www.w3.org/1999/xhtml/vocab#section",
+         (update_mapping_value_fp)rdfa_replace_string);
+      rdfa_update_mapping(context->term_mappings,
+         "start", "http://www.w3.org/1999/xhtml/vocab#start",
+         (update_mapping_value_fp)rdfa_replace_string);
+      rdfa_update_mapping(context->term_mappings,
+         "stylesheet", "http://www.w3.org/1999/xhtml/vocab#stylesheet",
+         (update_mapping_value_fp)rdfa_replace_string);
+      rdfa_update_mapping(context->term_mappings,
+         "subsection", "http://www.w3.org/1999/xhtml/vocab#subsection",
+         (update_mapping_value_fp)rdfa_replace_string);
+      rdfa_update_mapping(context->term_mappings,
+         "top", "http://www.w3.org/1999/xhtml/vocab#top",
+         (update_mapping_value_fp)rdfa_replace_string);
+      rdfa_update_mapping(context->term_mappings,
+         "up", "http://www.w3.org/1999/xhtml/vocab#up",
+         (update_mapping_value_fp)rdfa_replace_string);
+      rdfa_update_mapping(context->term_mappings,
+         "p3pv1", "http://www.w3.org/1999/xhtml/vocab#p3pv1",
+         (update_mapping_value_fp)rdfa_replace_string);
+
+      /* From the role attribute module */
+      rdfa_update_mapping(context->term_mappings,
+         "role", "http://www.w3.org/1999/xhtml/vocab#role",
+         (update_mapping_value_fp)rdfa_replace_string);
+   }
+
+   /* Setup the prefix and term mappings for HTML4 and HTML5 */
+   if(context->host_language == HOST_LANGUAGE_HTML)
+   {
+      /* No term or prefix mappings as of 2012-04-04 */
+   }
+
+#ifdef LIBRDFA_IN_RAPTOR
+   /* Raptor does this elsewhere */
+#else
+   /* Generate namespace triples for all values in the uri_mapping */
+   while(*mptr != NULL)
+   {
+      rdfa_next_mapping(mptr++, &key, &value);
+      mptr++;
+      rdfa_generate_namespace_triple(context, key, value);
+   }
+#endif
+}
+
+/**
+ * Creates a new context for the current element by cloning certain
+ * parts of the old context on the top of the given stack.
+ *
+ * @param context_stack the context stack that is associated with this
+ *                      processing run.
+ */
+rdfacontext* rdfa_create_new_element_context(rdfalist* context_stack)
+{
+   rdfacontext* parent_context = (rdfacontext*)
+      context_stack->items[context_stack->num_items - 1]->data;
+   rdfacontext* rval = rdfa_create_context(parent_context->base);
+
+   if(!rval)
+      return NULL;
+
+   /* * Otherwise, the values are: */
+
+   /* * the [ base ] is set to the [ base ] value of the current
+    *   [ evaluation context ]; */
+   rval->base = rdfa_replace_string(rval->base, parent_context->base);
+   rdfa_init_context(rval);
+
+   /* Set the processing depth as parent + 1 */
+   rval->depth = parent_context->depth + 1;
+
+   /* copy the URI mappings */
+#ifdef LIBRDFA_IN_RAPTOR
+   /* Raptor does this automatically for URIs */
+#else
+   rdfa_free_mapping(rval->uri_mappings, (free_mapping_value_fp)free);
+#endif
+   rdfa_free_mapping(rval->term_mappings, (free_mapping_value_fp)free);
+   rdfa_free_mapping(rval->list_mappings, (free_mapping_value_fp)rdfa_free_list);
+   rdfa_free_mapping(rval->local_list_mappings, (free_mapping_value_fp)rdfa_free_list);
+#ifdef LIBRDFA_IN_RAPTOR
+   /* Raptor does this automatically for URIs */
+#else
+   rval->uri_mappings =
+      rdfa_copy_mapping((void**)parent_context->uri_mappings,
+         (copy_mapping_value_fp)rdfa_replace_string);
+#endif
+   rval->term_mappings =
+      rdfa_copy_mapping((void**)parent_context->term_mappings,
+         (copy_mapping_value_fp)rdfa_replace_string);
+   rval->list_mappings =
+      rdfa_copy_mapping((void**)parent_context->local_list_mappings,
+         (copy_mapping_value_fp)rdfa_replace_list);
+   rval->local_list_mappings =
+      rdfa_copy_mapping((void**)parent_context->local_list_mappings,
+         (copy_mapping_value_fp)rdfa_replace_list);
+
+   /* inherit the parent context's host language and RDFa processor mode */
+   rval->host_language = parent_context->host_language;
+   rval->rdfa_version = parent_context->rdfa_version;
+
+   /* inherit the parent context's language */
+   if(parent_context->language != NULL)
+   {
+      rval->language =
+         rdfa_replace_string(rval->language, parent_context->language);
+   }
+
+   /* inherit the parent context's default vocabulary */
+   if(parent_context->default_vocabulary != NULL)
+   {
+      rval->default_vocabulary = rdfa_replace_string(
+         rval->default_vocabulary, parent_context->default_vocabulary);
+   }
+
+   /* set the callbacks callback */
+   rval->default_graph_triple_callback =
+      parent_context->default_graph_triple_callback;
+   rval->processor_graph_triple_callback =
+      parent_context->processor_graph_triple_callback;
+   rval->buffer_filler_callback = parent_context->buffer_filler_callback;
+
+   /* inherit the bnode count, _: bnode name, recurse flag, and state
+    * of the xml_literal_namespace_insertion */
+   rval->bnode_count = parent_context->bnode_count;
+   rval->underscore_colon_bnode_name =
+      rdfa_replace_string(rval->underscore_colon_bnode_name,
+                          parent_context->underscore_colon_bnode_name);
+   rval->recurse = parent_context->recurse;
+   rval->skip_element = 0;
+   rval->callback_data = parent_context->callback_data;
+   rval->xml_literal_namespaces_defined =
+      parent_context->xml_literal_namespaces_defined;
+   rval->xml_literal_xml_lang_defined =
+      parent_context->xml_literal_xml_lang_defined;
+
+#if 0
+   /* inherit the parent context's new_subject
+    * TODO: This is not anywhere in the syntax processing document */
+   if(parent_context->new_subject != NULL)
+   {
+      rval->new_subject = rdfa_replace_string(
+         rval->new_subject, parent_context->new_subject);
+   }
+#endif
+
+   if(parent_context->skip_element == 0)
+   {
+      /* o the [ parent subject ] is set to the value of [ new subject ],
+       *   if non-null, or the value of the [ parent subject ] of the
+       *   current [ evaluation context ]; */
+      if(parent_context->new_subject != NULL)
+      {
+         rval->parent_subject = rdfa_replace_string(
+            rval->parent_subject, parent_context->new_subject);
+      }
+      else
+      {
+         rval->parent_subject = rdfa_replace_string(
+            rval->parent_subject, parent_context->parent_subject);
+      }
+
+      /* o the [ parent object ] is set to value of [ current object
+       *   resource ], if non-null, or the value of [ new subject ], if
+       *   non-null, or the value of the [ parent subject ] of the
+       *   current [ evaluation context ]; */
+      if(parent_context->current_object_resource != NULL)
+      {
+         rval->parent_object =
+            rdfa_replace_string(
+               rval->parent_object, parent_context->current_object_resource);
+      }
+      else if(parent_context->new_subject != NULL)
+      {
+         rval->parent_object =
+            rdfa_replace_string(
+               rval->parent_object, parent_context->new_subject);
+      }
+      else
+      {
+         rval->parent_object =
+            rdfa_replace_string(
+               rval->parent_object, parent_context->parent_subject);
+      }
+
+      /* o the [ list of incomplete triples ] is set to the [ local list
+       *   of incomplete triples ]; */
+      rval->incomplete_triples = rdfa_replace_list(
+         rval->incomplete_triples, parent_context->local_incomplete_triples);
+   }
+   else
+   {
+      rval->parent_subject = rdfa_replace_string(
+         rval->parent_subject, parent_context->parent_subject);
+      rval->parent_object = rdfa_replace_string(
+         rval->parent_object, parent_context->parent_object);
+
+      /* copy the incomplete triples */
+      rval->incomplete_triples = rdfa_replace_list(
+         rval->incomplete_triples, parent_context->incomplete_triples);
+
+      /* copy the local list of incomplete triples */
+      rval->local_incomplete_triples = rdfa_replace_list(
+         rval->local_incomplete_triples,
+         parent_context->local_incomplete_triples);
+   }
+
+#ifdef LIBRDFA_IN_RAPTOR
+   rval->base_uri = parent_context->base_uri;
+   rval->sax2     = parent_context->sax2;
+   rval->namespace_handler = parent_context->namespace_handler;
+   rval->namespace_handler_user_data = parent_context->namespace_handler_user_data;
+#endif
+
+   return rval;
+}
+
+void rdfa_free_context_stack(rdfacontext* context)
+{
+   /* this field is not NULL only on the rdfacontext* at the top of the stack */
+   if(context->context_stack != NULL)
+   {
+      void* rval;
+      /* free the stack ensuring that we do not delete this context if
+       * it is in the list (which it may be, if parsing ended on error) */
+      do
+      {
+         rval = rdfa_pop_item(context->context_stack);
+         if(rval && rval != context)
+         {
+            rdfa_free_context((rdfacontext*)rval);
+         }
+      }
+      while(rval);
+      free(context->context_stack->items);
+      free(context->context_stack);
+      context->context_stack = NULL;
+   }
+}
+
+void rdfa_free_context(rdfacontext* context)
+{
+   free(context->base);
+   free(context->default_vocabulary);
+   free(context->parent_subject);
+   free(context->parent_object);
+
+#ifdef LIBRDFA_IN_RAPTOR
+#else
+   rdfa_free_mapping(context->uri_mappings, (free_mapping_value_fp)free);
+#endif
+
+   rdfa_free_mapping(context->term_mappings, (free_mapping_value_fp)free);
+   rdfa_free_list(context->incomplete_triples);
+   rdfa_free_mapping(context->list_mappings,
+      (free_mapping_value_fp)rdfa_free_list);
+   rdfa_free_mapping(context->local_list_mappings,
+      (free_mapping_value_fp)rdfa_free_list);
+   free(context->language);
+   free(context->underscore_colon_bnode_name);
+   free(context->new_subject);
+   free(context->current_object_resource);
+   free(context->about);
+   free(context->typed_resource);
+   free(context->resource);
+   free(context->href);
+   free(context->src);
+   free(context->content);
+   free(context->datatype);
+   rdfa_free_list(context->property);
+   free(context->plain_literal);
+   free(context->xml_literal);
+
+   /* TODO: These should be moved into their own data structure */
+   rdfa_free_list(context->local_incomplete_triples);
+
+   rdfa_free_context_stack(context);
+   free(context->working_buffer);
+   free(context);
+}