static void
rasqal_query_write_sparql_uri(sparql_writer_context *wc,
raptor_iostream* iostr, raptor_uri* uri)
{
size_t len;
unsigned char* string;
raptor_qname* qname;
qname = raptor_new_qname_from_namespace_uri(wc->nstack, uri, 10);
if(qname) {
const raptor_namespace* nspace = raptor_qname_get_namespace(qname);
if(!raptor_namespace_get_prefix(nspace))
raptor_iostream_write_byte(':', iostr);
raptor_qname_write(qname, iostr);
raptor_free_qname(qname);
return;
}
if(wc->base_uri)
string = raptor_uri_to_relative_counted_uri_string(wc->base_uri, uri, &len);
else
string = raptor_uri_as_counted_string(uri, &len);
raptor_iostream_write_byte('<', iostr);
raptor_string_ntriples_write(string, len, '>', iostr);
raptor_iostream_write_byte('>', iostr);
if(wc->base_uri)
raptor_free_memory(string);
}
/**
* raptor_uri_turtle_write:
* @world: world
* @iostr: iostream for writing
* @uri: uri
* @nstack: namespace stack
* @base_uri: base URI
*
* Write #raptor_uri to a stream in turtle syntax (using QNames).
*
* Return value: non-0 on failure
*/
int
raptor_uri_turtle_write(raptor_world *world,
raptor_iostream* iostr,
raptor_uri* uri,
raptor_namespace_stack *nstack,
raptor_uri *base_uri)
{
raptor_qname* qname;
raptor_turtle_writer* turtle_writer;
turtle_writer = raptor_new_turtle_writer(world, base_uri, 0, nstack, iostr);
if(!turtle_writer) {
return 1;
}
qname = raptor_new_qname_from_namespace_uri(nstack, uri, 10);
/* XML Names allow leading '_' and '.' anywhere but Turtle does not */
if(qname && !raptor_turtle_is_legal_turtle_qname(qname)) {
raptor_free_qname(qname);
qname = NULL;
}
if(qname) {
raptor_turtle_writer_qname(turtle_writer, qname);
raptor_free_qname(qname);
} else {
raptor_turtle_writer_reference(turtle_writer, uri);
}
raptor_free_turtle_writer(turtle_writer);
return 0;
}
/*
* raptor_turtle_emit_resource:
* @serializer: #raptor_serializer object
* @node: resource node
* @depth: depth into tree
*
* Emit a description of a resource using an XML Element
*
* Return value: non-0 on failure
**/
static int
raptor_turtle_emit_resource(raptor_serializer *serializer,
raptor_abbrev_node* node,
int depth)
{
raptor_turtle_context* context = (raptor_turtle_context*)serializer->context;
raptor_turtle_writer *turtle_writer = context->turtle_writer;
raptor_qname* qname = NULL;
RAPTOR_DEBUG5("Emitting resource node %p refcount %d subject %d object %d\n",
node,
node->ref_count, node->count_as_subject, node->count_as_object);
if(node->term->type != RAPTOR_TERM_TYPE_URI)
return 1;
qname = raptor_new_qname_from_namespace_uri(context->nstack,
node->term->value.uri, 10);
/* XML Names allow leading '_' and '.' anywhere but Turtle does not */
if(qname && !raptor_turtle_is_legal_turtle_qname(qname)) {
raptor_free_qname(qname);
qname = NULL;
}
if(qname) {
raptor_turtle_writer_qname(turtle_writer, qname);
raptor_free_qname(qname);
} else {
raptor_turtle_writer_reference(turtle_writer, node->term->value.uri);
}
RAPTOR_DEBUG2("Emitted %p\n", node);
return 0;
}
/*
* raptor_turtle_emit_subject_properties:
* @serializer: #raptor_serializer object
* @subject: subject node
* @depth: depth into tree
*
* Emit the properties about a subject node.
*
* Return value: non-0 on failure
**/
static int
raptor_turtle_emit_subject_properties(raptor_serializer* serializer,
raptor_abbrev_subject* subject,
int depth)
{
raptor_turtle_context* context = (raptor_turtle_context*)serializer->context;
raptor_turtle_writer *turtle_writer = context->turtle_writer;
raptor_abbrev_node* last_predicate = NULL;
int rv = 0;
raptor_avltree_iterator* iter = NULL;
int i;
RAPTOR_DEBUG5("Emitting subject properties for node %p refcount %d subject %d object %d\n",
subject->node, subject->node->ref_count,
subject->node->count_as_subject,
subject->node->count_as_object);
/* Emit any rdf:_n properties collected */
if(raptor_sequence_size(subject->list_items) > 0)
rv = raptor_turtle_emit_subject_list_items(serializer, subject, depth+1);
for(i = 0, (iter = raptor_new_avltree_iterator(subject->properties, NULL, NULL, 1));
iter && !rv;
i++, (rv = raptor_avltree_iterator_next(iter))) {
raptor_abbrev_node** nodes;
raptor_abbrev_node* predicate;
raptor_abbrev_node* object;
raptor_qname *qname;
nodes = (raptor_abbrev_node**)raptor_avltree_iterator_get(iter);
if(!nodes)
break;
predicate= nodes[0];
object= nodes[1];
if(!(last_predicate && raptor_abbrev_node_equals(predicate, last_predicate))) {
/* no object list abbreviation possible, terminate last object */
if(last_predicate) {
raptor_turtle_writer_raw(turtle_writer, (const unsigned char*)" ;");
raptor_turtle_writer_newline(turtle_writer);
}
qname = raptor_new_qname_from_namespace_uri(context->nstack,
predicate->term->value.uri,
10);
if(raptor_abbrev_node_equals(predicate, context->rdf_type))
raptor_turtle_writer_raw(turtle_writer, (const unsigned char*)"a");
else if(qname)
raptor_turtle_writer_qname(turtle_writer, qname);
else
raptor_turtle_writer_reference(turtle_writer, predicate->term->value.uri);
raptor_turtle_writer_raw(turtle_writer, (const unsigned char*)" ");
if(qname)
raptor_free_qname(qname);
} else
raptor_turtle_writer_raw(turtle_writer, (const unsigned char*)", ");
switch(object->term->type) {
case RAPTOR_TERM_TYPE_URI:
rv = raptor_turtle_emit_resource(serializer, object, depth+1);
break;
case RAPTOR_TERM_TYPE_LITERAL:
rv = raptor_turtle_emit_literal(serializer, object, depth+1);
break;
case RAPTOR_TERM_TYPE_BLANK:
rv = raptor_turtle_emit_blank(serializer, object, depth+1);
break;
case RAPTOR_TERM_TYPE_UNKNOWN:
default:
raptor_log_error_formatted(serializer->world, RAPTOR_LOG_LEVEL_ERROR,
NULL, "Triple has unsupported term type %d",
object->term->type);
break;
}
/* Return error if emitting something failed above */
if(rv)
return rv;
last_predicate = predicate;
}
if(iter)
raptor_free_avltree_iterator(iter);
return rv;
}
/**
* raptor_turtle_writer_literal:
* @turtle_writer: Turtle writer object
* @nstack: Namespace stack for making a QName for datatype URI
* @s: literal string to write (SHARED)
* @lang: language tag (may be NULL)
* @datatype: datatype URI (may be NULL)
*
* Write a literal (possibly with lang and datatype) to the Turtle writer.
*
* Return value: non-0 on failure
**/
int
raptor_turtle_writer_literal(raptor_turtle_writer* turtle_writer,
raptor_namespace_stack *nstack,
const unsigned char* s, const unsigned char* lang,
raptor_uri* datatype)
{
/* DBL_MAX = 309 decimal digits */
#define INT_MAX_LEN 309
/* DBL_EPSILON = 52 digits */
#define FRAC_MAX_LEN 52
char* endptr = (char *)s;
int written = 0;
/* typed literal special cases */
if(datatype) {
/* integer */
if(raptor_uri_equals(datatype, turtle_writer->xsd_integer_uri)) {
/* FIXME. Work around that gcc < 4.5 cannot disable warn_unused_result */
long gcc_is_stupid = strtol((const char*)s, &endptr, 10);
if(endptr != (char*)s && !*endptr) {
raptor_iostream_string_write(s, turtle_writer->iostr);
/* More gcc madness to 'use' the variable I didn't want */
written = 1 + 0 * (int)gcc_is_stupid;
} else {
raptor_log_error(turtle_writer->world, RAPTOR_LOG_LEVEL_ERROR, NULL,
"Illegal value for xsd:integer literal.");
}
/* double, decimal */
} else if(raptor_uri_equals(datatype, turtle_writer->xsd_double_uri) ||
raptor_uri_equals(datatype, turtle_writer->xsd_decimal_uri)) {
/* FIXME. Work around that gcc < 4.5 cannot disable warn_unused_result */
double gcc_is_doubly_stupid = strtod((const char*)s, &endptr);
if(endptr != (char*)s && !*endptr) {
raptor_iostream_string_write(s, turtle_writer->iostr);
/* More gcc madness to 'use' the variable I didn't want */
written = 1 + 0 * (int)gcc_is_doubly_stupid;
} else {
raptor_log_error(turtle_writer->world, RAPTOR_LOG_LEVEL_ERROR, NULL,
"Illegal value for xsd:double or xsd:decimal literal.");
}
/* boolean */
} else if(raptor_uri_equals(datatype, turtle_writer->xsd_boolean_uri)) {
if(!strcmp((const char*)s, "0") || !strcmp((const char*)s, "false")) {
raptor_iostream_string_write("false", turtle_writer->iostr);
written = 1;
} else if(!strcmp((const char*)s, "1") || !strcmp((const char*)s, "true")) {
raptor_iostream_string_write("true", turtle_writer->iostr);
written = 1;
} else {
raptor_log_error(turtle_writer->world, RAPTOR_LOG_LEVEL_ERROR, NULL,
"Illegal value for xsd:boolean literal.");
}
}
}
if(written)
return 0;
if(raptor_turtle_writer_quoted_counted_string(turtle_writer, s,
strlen((const char*)s)))
return 1;
/* typed literal, not a special case */
if(datatype) {
raptor_qname* qname;
raptor_iostream_string_write("^^", turtle_writer->iostr);
qname = raptor_new_qname_from_namespace_uri(nstack, datatype, 10);
if(qname) {
raptor_turtle_writer_qname(turtle_writer, qname);
raptor_free_qname(qname);
} else
raptor_turtle_writer_reference(turtle_writer, datatype);
} else if(lang) {
/* literal with language tag */
raptor_iostream_write_byte('@', turtle_writer->iostr);
raptor_iostream_string_write(lang, turtle_writer->iostr);
}
return 0;
}
