Adding upstream version 2.0.16.upstream/2.0.16upstream

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

1 files changed, 691 insertions, 0 deletions

diff --git a/librdfa/curie.c b/librdfa/curie.c
new file mode 100644
index 0000000..98ee7e0
--- /dev/null
+++ b/librdfa/curie.c
@@ -0,0 +1,691 @@
+/**
+ * Copyright 2008 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 CURIE module is used to resolve all forms of CURIEs that
+ * XHTML+RDFa accepts.
+ *
+ * @author Manu Sporny
+ */
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#ifdef HAVE_STRINGS_H
+#  include <strings.h>
+#endif
+#include <stdio.h>
+#include <ctype.h>
+#include "rdfa_utils.h"
+#include "rdfa.h"
+#include "strtok_r.h"
+
+/* The base XHTML vocab URL is used to resolve URIs that are reserved
+ * words. Any reserved listed above is appended to the URL below to
+ * form a complete IRI. */
+#define XHTML_VOCAB_URI "http://www.w3.org/1999/xhtml/vocab#"
+#define XHTML_VOCAB_URI_SIZE 35
+
+/**
+ * Gets the type of CURIE that is passed to it.
+ *
+ * @param uri the uri to check.
+ *
+ * @return either CURIE_TYPE_SAFE, CURIE_TYPE_URI or CURIE_TYPE_INVALID.
+ */
+static curie_t rdfa_get_curie_type(const char* uri)
+{
+   curie_t rval = CURIE_TYPE_INVALID;
+   
+   if(uri != NULL)
+   {
+      size_t uri_length = strlen(uri);
+
+      if((uri[0] == '[') && (uri[uri_length - 1] == ']'))
+      {
+         /* a safe curie starts with [ and ends with ] */
+         rval = CURIE_TYPE_SAFE;
+      }
+      else if(strstr(uri, ":") != NULL)
+      {
+         /* at this point, it is unknown whether or not the CURIE is
+          * an IRI or an unsafe CURIE */
+         rval = CURIE_TYPE_IRI_OR_UNSAFE;
+      }
+      else
+      {
+         /* if none of the above match, then the CURIE is probably a
+          * relative IRI */
+         rval = CURIE_TYPE_IRI_OR_UNSAFE;
+      }
+   }
+
+   return rval;
+}
+
+char* rdfa_resolve_uri(rdfacontext* context, const char* uri)
+{
+   char* rval = NULL;
+   char* path_start = NULL;
+   size_t base_length = strlen(context->base);
+   
+   if(strlen(uri) < 1)
+   {
+      /* if a blank URI is given, use the base context */
+      rval = rdfa_replace_string(rval, context->base);
+   }
+   else if(strstr(uri, ":") != NULL)
+   {
+      /* if a IRI is given, don't concatenate */
+      rval = rdfa_replace_string(rval, uri);
+   }
+   else if(uri[0] == '#' || uri[0] == '?')
+   {
+      /* if a fragment ID or start of a query parameter is given,
+       * concatenate it with the base URI */
+      rval = rdfa_join_string(context->base, uri);
+   }
+   else if(uri[0] == '/')
+   {
+      /* if a relative URI is given, but it starts with a '/', use the
+       * host part concatenated to the given URI */
+      char* tmp = NULL;
+      char* end_index = NULL;
+
+      /* initialize the working-set data */
+      tmp = rdfa_replace_string(tmp, context->base);
+      end_index = strchr(tmp, '/');
+
+
+      /* find the final '/' character after the host part of the context base. */
+      if(end_index != NULL)
+      {
+	 end_index = strchr(end_index + 1, '/');
+	
+	 if(end_index != NULL)
+	 {
+	    end_index = strchr(end_index + 1, '/');
+         }
+      }
+
+      /* if the '/' character after the host part was found, copy the host
+       * part and append the given URI to the URI, otherwise, append the
+       * host part and the URI part as-is, ensuring that a '/' exists at the
+       * end of the host part. */
+      if(end_index != NULL)
+      {
+         char* rval_copy;
+
+	 *end_index = '\0';
+	 
+	 /* if the '/' character after the host part was found, copy the host
+	  * part and append the given URI to the URI. */
+	 rval_copy = rdfa_replace_string(rval, tmp);
+	 rval = rdfa_join_string(rval_copy, uri);
+         free(rval_copy);
+      }
+      else
+      {
+	 /* append the host part and the URI part as-is, ensuring that a
+	  * '/' exists at the end of the host part. */
+ 	 size_t tlen = strlen(tmp) - 1;
+         char* rval_copy;
+
+	 rval_copy = rdfa_replace_string(rval, tmp);
+
+	 if(rval_copy[tlen] == '/')
+	 {
+	    rval_copy[tlen] = '\0';
+	 }
+	 rval = rdfa_join_string(rval_copy, uri);
+         free(rval_copy);
+      }
+
+      free(tmp);
+   }
+   else
+   {
+      if((char)context->base[base_length - 1] == '/')
+      {
+         /* if the base URI already ends in /, concatenate */
+         rval = rdfa_join_string(context->base, uri);
+      }
+      else
+      {
+         /* if we have a relative URI, chop off the name of the file
+          * and replace it with the relative pathname */
+         char* end_index = strrchr(context->base, '/');
+
+         if(end_index != NULL)
+         {
+            char* tmpstr = NULL;
+            char* end_index2;
+
+            tmpstr = rdfa_replace_string(tmpstr, context->base);
+            end_index2 = strrchr(tmpstr, '/');
+            if(end_index2 != NULL) {
+              end_index2++;
+              *end_index2 = '\0';
+            }
+
+            rval = rdfa_join_string(tmpstr, uri);
+            free(tmpstr);
+         }
+      }
+   }
+
+   /* It is possible that rval may be NULL here in OOM scenarios */
+   if(!rval)
+     return NULL;
+
+   /* Find the start of a scheme-based URL path */
+   path_start = (char*)strstr(rval, "://");
+   if(path_start != NULL)
+   {
+      if(strstr(path_start, "/.") != NULL)
+      {
+         path_start += 3;
+         path_start = strstr(path_start, "/");
+      }
+      else
+      {
+         path_start = NULL;
+      }
+   }
+
+   /* remove any dot-segments that remain in the URL for URLs w/ schemes */
+   if(path_start != NULL)
+   {
+      size_t rlen = strlen(rval) + 1;
+      size_t hlen = path_start - rval;
+      char* src = (char*)malloc(rlen + 4);
+      char* sptr = src + hlen;
+      char* dest = (char*)malloc(rlen + 1);
+      char* dptr = dest + hlen;
+      char* dfence = dptr;
+
+      memset(src, 0, rlen + 4);
+      memcpy(src, rval, rlen);
+      strncpy(dest, rval, hlen);
+
+      /* Process the path portion of the IRI */
+      while(sptr[0] != '?' && sptr[0] != '\0')
+      {
+         if(sptr[0] == '.' && sptr[1] == '.' && sptr[2] == '/')
+         {
+            /* A.  If the input buffer begins with a prefix of "../",
+             * then remove that prefix from the input buffer; otherwise,
+             */
+            sptr += 3;
+         }
+         else if(sptr[0] == '.' && sptr[1] == '/')
+         {
+            /* A.  If the input buffer begins with a prefix of "./",
+             * then remove that prefix from the input buffer; otherwise,
+             */
+            sptr += 2;
+         }
+         else if(sptr[0] == '/' && sptr[1] == '.' && sptr[2] == '/')
+         {
+            /* B.  if the input buffer begins with a prefix of "/./",
+             * then replace that prefix with "/" in the input buffer;
+             * otherwise,
+             */
+            sptr += 2;
+         }
+         else if(sptr[0] == '/' && sptr[1] == '.' && sptr[2] == '\0')
+         {
+            /* B.  if the input buffer begins with a prefix of "/.",
+             * where "." is a complete path segment, then replace that
+             * prefix with "/" in the input buffer; otherwise,
+             */
+            sptr += 1;
+            *sptr = '/';
+         }
+         else if(sptr[0] == '/' && sptr[1] == '.' && sptr[2] == '.' &&
+            ((sptr[3] == '/') || (sptr[3] == '\0')))
+         {
+            /* C.  if the input buffer begins with a prefix of "/../",
+             * then replace that prefix with "/" in the input buffer and
+             * remove the last segment and its preceding "/" (if any) from
+             * the output buffer; otherwise,
+             */
+            if(sptr[3] == '/')
+            {
+               sptr += 3;
+            }
+            else if(sptr[3] == '\0')
+            {
+               sptr += 2;
+               *sptr = '/';
+            }
+
+            /* remove the last segment and the preceding '/' */
+            if(dptr > dfence)
+            {
+               dptr--;
+               if(dptr[0] == '/')
+               {
+                  dptr--;
+               }
+            }
+            while(dptr >= dfence && dptr[0] != '/')
+            {
+               dptr--;
+            }
+            if(dptr >= dfence)
+            {
+               dptr[0] = '\0';
+            }
+            else
+            {
+               dptr = dfence;
+               dptr[0] = '\0';
+            }
+         }
+         else if(sptr[0] == '.' && sptr[1] == '\0')
+         {
+            /* D. if the input buffer consists only of ".", then remove
+             * that from the input buffer; otherwise,
+             */
+            sptr++;
+
+         }
+         else if(sptr[0] == '.' && sptr[1] == '.' && sptr[2] == '\0')
+         {
+            /* D. if the input buffer consists only of "..", then remove
+             * that from the input buffer; otherwise,
+             */
+            sptr += 2;
+         }
+         else
+         {
+            /* Copy the path segment */
+            do
+            {
+               *dptr++ = *sptr++;
+               *dptr = '\0';
+            } while(sptr[0] != '/' && sptr[0] != '?' && sptr[0] != '\0');
+         }
+      }
+
+      /* Copy the remaining query parameters */
+      if(sptr[0] == '?')
+      {
+         size_t rest_len = strlen(sptr);
+         memcpy(dptr, sptr, rest_len + 1);
+      }
+      else
+      {
+         dptr[0] = '\0';
+      }
+
+      free(rval);
+      free(src);
+      rval = dest;
+   }
+
+   return rval;
+}
+
+char* rdfa_resolve_curie(
+   rdfacontext* context, const char* uri, curieparse_t mode)
+{
+   char* rval = NULL;
+   curie_t ctype = rdfa_get_curie_type(uri);
+
+   if(!uri)
+      return NULL;
+
+   if(ctype == CURIE_TYPE_INVALID)
+   {
+      rval = NULL;
+   }
+   else if((ctype == CURIE_TYPE_IRI_OR_UNSAFE) &&
+           ((mode == CURIE_PARSE_HREF_SRC) ||
+            (context->rdfa_version == RDFA_VERSION_1_0 &&
+               mode == CURIE_PARSE_ABOUT_RESOURCE)))
+   {
+      /* If we are parsing something that can take either a CURIE or a
+       * URI, and the type is either IRI or UNSAFE, assume that it is
+       * an IRI */
+      rval = rdfa_resolve_uri(context, uri);
+   }
+
+   /*
+    * Check to see if the value is a term.
+    */
+   if(ctype == CURIE_TYPE_IRI_OR_UNSAFE && mode == CURIE_PARSE_PROPERTY)
+   {
+      const char* term_iri;
+      term_iri = (const char*)rdfa_get_mapping(context->term_mappings, uri);
+      if(term_iri != NULL)
+      {
+         rval = rdfa_strdup(term_iri);
+      }
+      else if(context->default_vocabulary == NULL && strstr(uri, ":") == NULL)
+      {
+         /* Generate the processor warning if this is a missing term */
+#define FORMAT_1 "The use of the '%s' term was unrecognized by the RDFa processor because it is not a valid term for the current Host Language."
+
+#ifdef LIBRDFA_IN_RAPTOR
+         raptor_parser_warning((raptor_parser*)context->callback_data, 
+                               FORMAT_1, uri);
+#else
+         char msg[1024];
+         snprintf(msg, 1024, FORMAT_1, uri);
+
+         rdfa_processor_triples(context, RDFA_PROCESSOR_WARNING, msg);
+#endif
+      }
+   }
+
+   /* if we are processing a safe CURIE OR
+    * if we are parsing an unsafe CURIE that is an @type_of,
+    * @datatype, @property, @rel, or @rev attribute, treat the curie
+    * as not an IRI, but an unsafe CURIE */
+   if(rval == NULL && ((ctype == CURIE_TYPE_SAFE) ||
+         ((ctype == CURIE_TYPE_IRI_OR_UNSAFE) &&
+          ((mode == CURIE_PARSE_INSTANCEOF_DATATYPE) ||
+           (mode == CURIE_PARSE_PROPERTY) ||
+           (mode == CURIE_PARSE_RELREV) ||
+           (context->rdfa_version == RDFA_VERSION_1_1 &&
+              mode == CURIE_PARSE_ABOUT_RESOURCE)))))
+   {
+      char* working_copy = NULL;
+      char* wcptr = NULL;
+      char* prefix = NULL;
+      char* curie_reference = NULL;
+      const char* expanded_prefix = NULL;
+      size_t uri_len = strlen(uri);
+      working_copy = (char*)malloc(uri_len + 1);
+      memcpy(working_copy, uri, uri_len + 1);/*rdfa_replace_string(working_copy, uri);*/
+
+      /* if this is a safe CURIE, chop off the beginning and the end */
+      if(ctype == CURIE_TYPE_SAFE)
+      {
+         prefix = strtok_r(working_copy, "[:]", &wcptr);
+         if(wcptr)
+            curie_reference = strtok_r(NULL, "[]", &wcptr);
+      }
+      else if(ctype == CURIE_TYPE_IRI_OR_UNSAFE)
+      {
+         prefix = strtok_r(working_copy, ":", &wcptr);
+         if(wcptr)
+            curie_reference = strtok_r(NULL, "", &wcptr);
+      }
+
+      /* fully resolve the prefix and get its length */
+
+      /* if a colon was found, but no prefix, use the XHTML vocabulary URI
+       * as the expanded prefix */
+      if((uri[0] == ':') || (strcmp(uri, "[:]") == 0))
+      {
+         expanded_prefix = XHTML_VOCAB_URI;
+         curie_reference = prefix;
+         prefix = NULL;
+      }
+      else if(uri[0] == ':')
+      {
+         /* FIXME: This looks like a bug - don't know why this code is
+          * in here. I think it's for the case where ":next" is
+          * specified, but the code's not checking that -- manu */
+         expanded_prefix = context->base;
+         curie_reference = prefix;
+         prefix = NULL;
+      }
+      else if(prefix != NULL)
+      {
+         if((mode != CURIE_PARSE_PROPERTY) &&
+            (mode != CURIE_PARSE_RELREV) &&
+            strcmp(prefix, "_") == 0)
+         {
+            /* if the prefix specifies this as a blank node, then we
+             * use the blank node prefix */
+            expanded_prefix = "_";
+         }
+         else
+         {
+            /* if the prefix was defined, get it from the set of URI mappings. */
+#ifdef LIBRDFA_IN_RAPTOR
+            if(!strcmp(prefix, "xml"))
+            {
+               expanded_prefix = RAPTOR_GOOD_CAST(const char*, raptor_xml_namespace_uri);
+            }
+            else
+            {
+               raptor_namespace *nspace;
+               raptor_uri* ns_uri;
+               nspace = raptor_namespaces_find_namespace(&context->sax2->namespaces,
+                                                         (const unsigned char*)prefix,
+                                                         (int)strlen(prefix));
+               if(nspace) {
+                  ns_uri = raptor_namespace_get_uri(nspace);
+                  if(ns_uri)
+                     expanded_prefix = (const char*)raptor_uri_as_string(ns_uri);
+               }
+            }
+#else
+            expanded_prefix =
+               rdfa_get_mapping(context->uri_mappings, prefix);
+
+            /* Generate the processor warning if the prefix was not found */
+            if(expanded_prefix == NULL && strstr(uri, ":") != NULL &&
+               strstr(uri, "://") == NULL)
+            {
+#define FORMAT_2 "The '%s' prefix was not found. You may want to check that it is declared before it is used, or that it is a valid prefix string."
+#ifdef LIBRDFA_IN_RAPTOR
+              raptor_parser_warning((raptor_parser*)context->callback_data, 
+                                    FORMAT_2, prefix);
+#else
+              char msg[1024];
+              snprintf(msg, 1024, FORMAT_2, prefix);
+
+               rdfa_processor_triples(context, RDFA_PROCESSOR_WARNING, msg);
+#endif
+            }
+#endif
+         }
+      }
+
+      if((expanded_prefix != NULL) && (curie_reference != NULL))
+      {
+         /* if the expanded prefix and the reference exist, generate the
+          * full IRI. */
+         if(strcmp(expanded_prefix, "_") == 0)
+         {
+            rval = rdfa_join_string("_:", curie_reference);
+         }
+         else
+         {
+            rval = rdfa_join_string(expanded_prefix, curie_reference);
+         }
+      }
+      else if((expanded_prefix != NULL) && (expanded_prefix[0] != '_') && 
+         (curie_reference == NULL))
+      {
+         /* if the expanded prefix exists, but the reference is null,
+          * generate the CURIE because a reference-less CURIE is still
+          * valid */
+ 	 rval = rdfa_join_string(expanded_prefix, "");
+      }
+
+      free(working_copy);
+   }
+
+   if(rval == NULL)
+   {
+      /* if we're NULL at this point, the CURIE might be the special
+       * unnamed bnode specified by _: */
+      if((strcmp(uri, "[_:]") == 0) || (strcmp(uri, "_:") == 0))
+      {
+         if(context->underscore_colon_bnode_name == NULL)
+         {
+            context->underscore_colon_bnode_name = rdfa_create_bnode(context);
+         }
+         rval = rdfa_replace_string(rval, context->underscore_colon_bnode_name);
+      }
+      /* if we're NULL at this point and the IRI isn't [], then this might be
+       * an IRI */
+      else if(context->rdfa_version == RDFA_VERSION_1_1 &&
+         (strcmp(uri, "[]") != 0))
+      {
+         if((context->default_vocabulary != NULL) &&
+            ((mode == CURIE_PARSE_PROPERTY) || (mode == CURIE_PARSE_RELREV) ||
+               (mode == CURIE_PARSE_INSTANCEOF_DATATYPE)) &&
+            (strstr(uri, ":") == NULL))
+         {
+            rval = rdfa_join_string(context->default_vocabulary, uri);
+         }
+         else if(((mode == CURIE_PARSE_PROPERTY) ||
+            (mode == CURIE_PARSE_ABOUT_RESOURCE) ||
+            (mode == CURIE_PARSE_INSTANCEOF_DATATYPE)) &&
+            (strstr(uri, "_:") == NULL) && (strstr(uri, "[_:") == NULL))
+         {
+            rval = rdfa_resolve_uri(context, uri);
+         }
+      }
+   }
+   
+   /* even though a reference-only CURIE is valid, it does not
+    * generate a triple in XHTML+RDFa. If we're NULL at this point,
+    * the given value wasn't valid in XHTML+RDFa. */
+   
+   return rval;
+}
+
+/**
+ * Resolves a given uri depending on whether or not it is a fully
+ * qualified IRI, a CURIE, or a short-form XHTML reserved word for
+ * @rel or @rev as defined in the XHTML+RDFa Syntax Document.
+ *
+ * @param context the current processing context.
+ * @param uri the URI part to process.
+ *
+ * @return the fully qualified IRI, or NULL if the conversion failed
+ *         due to the given URI not being a short-form XHTML reserved
+ *         word. The memory returned from this function MUST be freed.
+ */
+char* rdfa_resolve_relrev_curie(rdfacontext* context, const char* uri)
+{
+   char* rval = NULL;
+   const char* resource = uri;
+
+   /* check to make sure the URI doesn't have an empty prefix */
+   if(uri[0] == ':')
+   {
+      resource++;
+   }
+
+   /* override reserved words if there is a default vocab defined
+    * NOTE: Don't have to check for RDFa 1.1 mode because vocab is only defined
+    * in RDFa 1.1 */
+   if(context->default_vocabulary != NULL)
+   {
+      rval = rdfa_resolve_curie(context, uri, CURIE_PARSE_RELREV);
+   }
+   else if(context->host_language == HOST_LANGUAGE_XHTML1)
+   {
+      /* search all of the XHTML @rel/@rev reserved words for a
+       * case-insensitive match against the given URI */
+      char* term = rdfa_strdup(resource);
+      char* ptr = NULL;
+
+      for(ptr = term; *ptr; ptr++)
+      {
+        *ptr = RAPTOR_GOOD_CAST(char, tolower(*ptr));
+      }
+
+      rval = (char*)rdfa_get_mapping(context->term_mappings, term);
+      if(rval != NULL)
+      {
+         rval = rdfa_strdup(rval);
+      }
+      free(term);
+   }
+   else
+   {
+      /* Search the term mappings for a match */
+      rval = (char*)rdfa_get_mapping(context->term_mappings, resource);
+      if(rval != NULL)
+      {
+         rval = rdfa_strdup(rval);
+      }
+   }
+
+   /* if a search against the registered terms failed,
+    * attempt to resolve the value as a standard CURIE */
+   if(rval == NULL)
+   {
+      rval = rdfa_resolve_curie(context, uri, CURIE_PARSE_RELREV);
+   }
+
+   /* if a CURIE wasn't found, attempt to resolve the value as an IRI */
+   if(rval == NULL && (context->rdfa_version == RDFA_VERSION_1_1))
+   {
+      rval = rdfa_resolve_uri(context, uri);
+   }
+   
+   return rval;
+}
+
+rdfalist* rdfa_resolve_curie_list(
+   rdfacontext* rdfa_context, const char* uris, curieparse_t mode)
+{
+   rdfalist* rval = rdfa_create_list(3);
+   char* working_uris = NULL;
+   char* uptr = NULL;
+   char* ctoken = NULL;
+   working_uris = rdfa_replace_string(working_uris, uris);
+
+   /* go through each item in the list of CURIEs and resolve each */
+   ctoken = strtok_r(working_uris, RDFA_WHITESPACE, &uptr);
+   
+   while(ctoken != NULL)
+   {
+      char* resolved_curie = NULL;
+
+      if((mode == CURIE_PARSE_INSTANCEOF_DATATYPE) ||
+         (mode == CURIE_PARSE_ABOUT_RESOURCE) ||
+         (mode == CURIE_PARSE_PROPERTY))
+      {
+         resolved_curie =
+            rdfa_resolve_curie(rdfa_context, ctoken, mode);
+      }
+      else if(mode == CURIE_PARSE_RELREV)
+      {
+         resolved_curie =
+            rdfa_resolve_relrev_curie(rdfa_context, ctoken);
+      }
+
+      /* add the CURIE if it was a valid one */
+      if(resolved_curie != NULL)
+      {
+         rdfa_add_item(rval, resolved_curie, RDFALIST_FLAG_TEXT);
+         free(resolved_curie);
+      }
+      
+      ctoken = strtok_r(NULL, RDFA_WHITESPACE, &uptr);
+   }
+   
+   free(working_uris);
+
+   return rval;
+}