Adding upstream version 2.0.16.upstream/2.0.16upstream

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

1 files changed, 342 insertions, 0 deletions

diff --git a/src/raptor_serialize_ntriples.c b/src/raptor_serialize_ntriples.c
new file mode 100644
index 0000000..6ccdee8
--- /dev/null
+++ b/src/raptor_serialize_ntriples.c
@@ -0,0 +1,342 @@
+/* -*- Mode: c; c-basic-offset: 2 -*-
+ *
+ * raptor_serialize_ntriples.c - N-Triples and Nquads serializer
+ *
+ * Copyright (C) 2004-2010, David Beckett http://www.dajobe.org/
+ * Copyright (C) 2004-2005, University of Bristol, UK http://www.bristol.ac.uk/
+ *
+ * This package is Free Software and part of Redland http://librdf.org/
+ * 
+ * It is licensed under the following three licenses as alternatives:
+ *   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.html or LICENSE.txt at the top of this package for the
+ * complete terms and further detail along with the license texts for
+ * the licenses in COPYING.LIB, COPYING and LICENSE-2.0.txt respectively.
+ * 
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <raptor_config.h>
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdarg.h>
+#ifdef HAVE_ERRNO_H
+#include <errno.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+/* Raptor includes */
+#include "raptor2.h"
+#include "raptor_internal.h"
+
+
+/*
+ * Raptor N-Triples serializer object
+ */
+typedef struct {
+  int is_nquads;
+} raptor_ntriples_serializer_context;
+
+
+
+/* create a new serializer */
+static int
+raptor_ntriples_serialize_init(raptor_serializer* serializer, const char *name)
+{
+  raptor_ntriples_serializer_context* ntriples_serializer;
+
+  ntriples_serializer = (raptor_ntriples_serializer_context*)serializer->context;
+  ntriples_serializer->is_nquads = !strcmp(name, "nquads");
+
+  return 0;
+}
+  
+
+/* destroy a serializer */
+static void
+raptor_ntriples_serialize_terminate(raptor_serializer* serializer)
+{
+
+}
+  
+
+/* add a namespace */
+static int
+raptor_ntriples_serialize_declare_namespace(raptor_serializer* serializer, 
+                                            raptor_uri *uri,
+                                            const unsigned char *prefix)
+{
+  /* NOP */
+  return 0;
+}
+
+
+#if 0
+/* start a serialize */
+static int
+raptor_ntriples_serialize_start(raptor_serializer* serializer)
+{
+  return 0;
+}
+#endif
+
+
+
+/**
+ * raptor_string_ntriples_write:
+ * @string: UTF-8 string to write
+ * @len: length of UTF-8 string
+ * @delim: Terminating delimiter character for string (such as " or >)
+ * or \0 for no escaping.
+ * @iostr: #raptor_iostream to write to
+ *
+ * Write an UTF-8 string using N-Triples escapes to an iostream.
+ * 
+ * Return value: non-0 on failure such as bad UTF-8 encoding.
+ **/
+int
+raptor_string_ntriples_write(const unsigned char *string,
+                             size_t len,
+                             const char delim,
+                             raptor_iostream *iostr)
+{
+  return raptor_string_escaped_write(string, len, delim,
+                                     RAPTOR_ESCAPED_WRITE_NTRIPLES_LITERAL,
+                                     iostr);
+}
+
+
+/**
+ * raptor_bnodeid_ntriples_write:
+ * @bnodeid: bnode ID to write
+ * @len: length of bnode ID
+ * @iostr: #raptor_iostream to write to
+ *
+ * Write a blank node ID in a form legal for N-Triples with _: prefix
+ *
+ * Return value: non-0 on failure
+ **/
+int
+raptor_bnodeid_ntriples_write(const unsigned char *bnodeid,
+                              size_t len,
+                              raptor_iostream *iostr)
+{
+  unsigned int i;
+
+  raptor_iostream_counted_string_write("_:", 2, iostr);
+
+  for(i = 0; i < len; i++) {
+    unsigned char c = *bnodeid++;
+    if(!isalpha(c) && !isdigit(c)) {
+      /* Replace characters not in legal N-Triples bnode set */
+      c = 'z';
+    }
+    raptor_iostream_write_byte(c, iostr);
+  }
+
+  return 0;
+}
+
+
+/**
+ * raptor_term_ntriples_write:
+ * @term: term to write
+ * @iostr: raptor iostream
+ * 
+ * Write a #raptor_term formatted in N-Triples format to a #raptor_iostream
+ * 
+ * @Deprecated: Use raptor_term_escaped_write() that allows
+ * configuring format detail flags.
+ *
+ * Return value: non-0 on failure
+ **/
+int
+raptor_term_ntriples_write(const raptor_term *term, raptor_iostream* iostr)
+{
+  return raptor_term_escaped_write(term,
+                                   RAPTOR_ESCAPED_WRITE_NTRIPLES_LITERAL,
+                                   iostr);
+}
+
+
+/**
+ * raptor_statement_ntriples_write:
+ * @statement: statement to write
+ * @iostr: raptor iostream
+ * @write_graph_term: flag to write graph term if present
+ * 
+ * Write a #raptor_statement formatted in N-Triples or N-Quads format
+ * to a #raptor_iostream
+ * 
+ * Return value: non-0 on failure
+ **/
+int
+raptor_statement_ntriples_write(const raptor_statement *statement,
+                                raptor_iostream* iostr,
+                                int write_graph_term)
+{
+  unsigned int flags = RAPTOR_ESCAPED_WRITE_NTRIPLES_LITERAL;
+
+  RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(statement, raptor_statement, 1);
+
+  if(raptor_term_escaped_write(statement->subject, flags, iostr))
+    return 1;
+  
+  raptor_iostream_write_byte(' ', iostr);
+  if(raptor_term_escaped_write(statement->predicate, flags, iostr))
+    return 1;
+  
+  raptor_iostream_write_byte(' ', iostr);
+  if(raptor_term_escaped_write(statement->object, flags, iostr))
+    return 1;
+
+  if(statement->graph && write_graph_term) {
+    raptor_iostream_write_byte(' ', iostr);
+    if(raptor_term_escaped_write(statement->graph, flags, iostr))
+      return 1;
+  }
+  
+  raptor_iostream_counted_string_write(" .\n", 3, iostr);
+
+  return 0;
+}
+
+
+/* serialize a statement */
+static int
+raptor_ntriples_serialize_statement(raptor_serializer* serializer, 
+                                    raptor_statement *statement)
+{
+  raptor_ntriples_serializer_context* ntriples_serializer;
+
+  ntriples_serializer = (raptor_ntriples_serializer_context*)serializer->context;
+
+  raptor_statement_ntriples_write(statement,
+                                  serializer->iostream,
+                                  ntriples_serializer->is_nquads);
+  return 0;
+}
+
+
+#if 0
+/* end a serialize */
+static int
+raptor_ntriples_serialize_end(raptor_serializer* serializer)
+{
+  return 0;
+}
+#endif
+  
+/* finish the serializer factory */
+static void
+raptor_ntriples_serialize_finish_factory(raptor_serializer_factory* factory)
+{
+
+}
+
+
+#ifdef RAPTOR_SERIALIZER_NTRIPLES
+static const char* const ntriples_names[2] = { "ntriples", NULL};
+
+static const char* const ntriples_uri_strings[3] = {
+  "http://www.w3.org/ns/formats/N-Triples",
+  "http://www.w3.org/TR/rdf-testcases/#ntriples",
+  NULL
+};
+  
+#define NTRIPLES_TYPES_COUNT 2
+static const raptor_type_q ntriples_types[NTRIPLES_TYPES_COUNT + 1] = {
+  { "application/n-triples", 21, 10}, 
+  { "text/plain", 10, 1}, 
+  { NULL, 0, 0}
+};
+
+static int
+raptor_ntriples_serializer_register_factory(raptor_serializer_factory *factory)
+{
+  factory->desc.names = ntriples_names;
+  factory->desc.mime_types = ntriples_types;
+
+  factory->desc.label =  "N-Triples";
+  factory->desc.uri_strings = ntriples_uri_strings;
+
+  factory->context_length     = sizeof(raptor_ntriples_serializer_context);
+  
+  factory->init                = raptor_ntriples_serialize_init;
+  factory->terminate           = raptor_ntriples_serialize_terminate;
+  factory->declare_namespace   = raptor_ntriples_serialize_declare_namespace;
+  factory->serialize_start     = NULL;
+  factory->serialize_statement = raptor_ntriples_serialize_statement;
+  factory->serialize_end       = NULL;
+  factory->finish_factory      = raptor_ntriples_serialize_finish_factory;
+
+  return 0;
+}
+#endif
+
+
+#ifdef RAPTOR_SERIALIZER_NQUADS
+static const char* const nquads_names[2] = { "nquads", NULL};
+
+static const char* const nquads_uri_strings[2] = {
+  "http://sw.deri.org/2008/07/n-quads/#n-quads",
+  NULL
+};
+  
+#define NQUADS_TYPES_COUNT 1
+static const raptor_type_q nquads_types[NQUADS_TYPES_COUNT + 1] = {
+  { "text/x-nquads", 13, 10},
+  { NULL, 0, 0}
+};
+
+static int
+raptor_nquads_serializer_register_factory(raptor_serializer_factory *factory)
+{
+  factory->desc.names = nquads_names;
+  factory->desc.mime_types = nquads_types;
+
+  factory->desc.label = "N-Quads";
+  factory->desc.uri_strings = nquads_uri_strings;
+
+  factory->context_length     = sizeof(raptor_ntriples_serializer_context);
+  
+  factory->init                = raptor_ntriples_serialize_init;
+  factory->terminate           = raptor_ntriples_serialize_terminate;
+  factory->declare_namespace   = raptor_ntriples_serialize_declare_namespace;
+  factory->serialize_start     = NULL;
+  factory->serialize_statement = raptor_ntriples_serialize_statement;
+  factory->serialize_end       = NULL;
+  factory->finish_factory      = raptor_ntriples_serialize_finish_factory;
+
+  return 0;
+}
+#endif
+
+#ifdef RAPTOR_SERIALIZER_NTRIPLES
+int
+raptor_init_serializer_ntriples(raptor_world* world)
+{
+  return !raptor_serializer_register_factory(world,
+                                             &raptor_ntriples_serializer_register_factory);
+}
+#endif
+
+#ifdef RAPTOR_SERIALIZER_NQUADS
+int
+raptor_init_serializer_nquads(raptor_world* world)
+{
+  return !raptor_serializer_register_factory(world,
+                                             &raptor_nquads_serializer_register_factory);
+}
+#endif