/**
* raptor_free_xml_element:
* @element: XML Element
*
* Destructor - destroy a raptor_xml_element object.
**/
void
raptor_free_xml_element(raptor_xml_element *element)
{
unsigned int i;
if(!element)
return;
for(i = 0; i < element->attribute_count; i++)
if(element->attributes[i])
raptor_free_qname(element->attributes[i]);
if(element->attributes)
RAPTOR_FREE(raptor_qname_array, element->attributes);
if(element->content_cdata_sb)
raptor_free_stringbuffer(element->content_cdata_sb);
if(element->base_uri)
raptor_free_uri(element->base_uri);
if(element->xml_language)
RAPTOR_FREE(char*, element->xml_language);
raptor_free_qname(element->name);
if(element->declared_nspaces)
raptor_free_sequence(element->declared_nspaces);
RAPTOR_FREE(raptor_element, element);
}
/*
* 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->type != RAPTOR_IDENTIFIER_TYPE_RESOURCE)
return 1;
qname = raptor_namespaces_qname_from_uri(context->nstack,
node->value.resource.uri, 10);
if(qname) {
raptor_turtle_writer_qname(turtle_writer, qname);
raptor_free_qname(qname);
} else {
raptor_turtle_writer_reference(turtle_writer, node->value.resource.uri);
}
RAPTOR_DEBUG2("Emitted %p\n", node);
return 0;
}
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_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_new_xml_element_from_namespace_local_name:
* @ns: namespace
* @name: the XML element local name
* @xml_language: the in-scope XML language (or NULL)
* @xml_base: base uri (or NULL)
*
* Constructor - create a new XML element from an XML namespace and a local name
*
* Added in 1.4.16.
*
* Return value: a new #raptor_xml_element or NULL on failure
*/
raptor_xml_element*
raptor_new_xml_element_from_namespace_local_name(raptor_namespace *ns,
const unsigned char *name,
const unsigned char *xml_language,
raptor_uri *xml_base)
{
raptor_uri *base_uri_copy;
raptor_qname *qname;
raptor_xml_element *element = NULL;
qname = raptor_new_qname_from_namespace_local_name(ns->nstack->world, ns,
name, NULL);
if(qname) {
base_uri_copy = xml_base ? raptor_uri_copy(xml_base) : NULL;
element = raptor_new_xml_element(qname, xml_language, base_uri_copy);
if(!element) {
raptor_free_qname(qname);
if(base_uri_copy)
raptor_free_uri(base_uri_copy);
}
}
return element;
}
/*
* 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);
}
if(predicate->type == RAPTOR_IDENTIFIER_TYPE_ORDINAL) {
/* we should only get here in rare cases -- usually when there
* are multiple ordinals with the same value. */
unsigned char uri_string[MAX_ASCII_INT_SIZE + 2];
sprintf((char*)uri_string, "_%d", predicate->value.ordinal.ordinal);
qname = raptor_new_qname_from_namespace_local_name_v2(serializer->world,
context->rdf_nspace,
uri_string,
NULL);
} else {
qname = raptor_namespaces_qname_from_uri(context->nstack,
predicate->value.resource.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->value.resource.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->type) {
case RAPTOR_IDENTIFIER_TYPE_RESOURCE:
rv = raptor_turtle_emit_resource(serializer, object, depth+1);
break;
case RAPTOR_IDENTIFIER_TYPE_LITERAL:
rv = raptor_turtle_emit_literal(serializer, object, depth+1);
break;
case RAPTOR_IDENTIFIER_TYPE_ANONYMOUS:
rv = raptor_turtle_emit_blank(serializer, object, depth+1);
break;
case RAPTOR_IDENTIFIER_TYPE_XML_LITERAL:
rv = raptor_turtle_emit_xml_literal(serializer, object, depth+1);
break;
case RAPTOR_IDENTIFIER_TYPE_ORDINAL:
/* ordinals should never appear as an object with current parsers */
case RAPTOR_IDENTIFIER_TYPE_PREDICATE:
/* predicates should never appear as an object */
case RAPTOR_IDENTIFIER_TYPE_UNKNOWN:
default:
RAPTOR_FATAL1("Unsupported identifier type\n");
break;
}
last_predicate = predicate;
}
if (iter)
raptor_free_avltree_iterator(iter);
return rv;
}
/* start of an element */
void
raptor_sax2_start_element(void* user_data, const unsigned char *name,
const unsigned char **atts)
{
raptor_sax2* sax2=(raptor_sax2*)user_data;
raptor_qname* el_name;
unsigned char **xml_atts_copy=NULL;
size_t xml_atts_size=0;
int all_atts_count=0;
int ns_attributes_count=0;
raptor_qname** named_attrs=NULL;
raptor_xml_element* xml_element=NULL;
unsigned char *xml_language=NULL;
raptor_uri *xml_base=NULL;
if(sax2->failed)
return;
#ifdef RAPTOR_XML_EXPAT
#ifdef EXPAT_UTF8_BOM_CRASH
sax2->tokens_count++;
#endif
#endif
#ifdef RAPTOR_XML_LIBXML
if(atts) {
int i;
/* Do XML attribute value normalization */
for (i = 0; atts[i]; i+=2) {
unsigned char *value=(unsigned char*)atts[i+1];
unsigned char *src = value;
unsigned char *dst = xmlStrdup(value);
if(!dst) {
raptor_log_error_to_handlers(sax2->world,
sax2->error_handlers,
RAPTOR_LOG_LEVEL_FATAL,
sax2->locator, "Out of memory");
return;
}
atts[i+1]=dst;
while (*src == 0x20 || *src == 0x0d || *src == 0x0a || *src == 0x09)
src++;
while (*src) {
if (*src == 0x20 || *src == 0x0d || *src == 0x0a || *src == 0x09) {
while (*src == 0x20 || *src == 0x0d || *src == 0x0a || *src == 0x09)
src++;
if (*src)
*dst++ = 0x20;
} else {
*dst++ = *src++;
}
}
*dst = '\0';
xmlFree(value);
}
}
#endif
raptor_sax2_inc_depth(sax2);
if(atts) {
int i;
/* Save passed in XML attributes pointers so we can
* NULL the pointers when they get handled below (various atts[i]=NULL)
*/
for (i = 0; atts[i]; i++) ;
xml_atts_size=sizeof(unsigned char*) * i;
if(xml_atts_size) {
xml_atts_copy=(unsigned char**)RAPTOR_MALLOC(cstringpointer,xml_atts_size);
if(!xml_atts_copy)
goto fail;
memcpy(xml_atts_copy, atts, xml_atts_size);
}
/* XML attributes processing:
* xmlns* - XML namespaces (Namespaces in XML REC)
* Deleted and used to synthesise namespaces declarations
* xml:lang - XML language (XML REC)
* Deleted and optionally normalised to lowercase
* xml:base - XML Base (XML Base REC)
* Deleted and used to set the in-scope base URI for this XML element
*/
for (i = 0; atts[i]; i+= 2) {
all_atts_count++;
if(strncmp((char*)atts[i], "xml", 3)) {
/* count and skip non xml* attributes */
ns_attributes_count++;
continue;
}
/* synthesise the XML namespace events */
if(!memcmp((const char*)atts[i], "xmlns", 5)) {
const unsigned char *prefix=atts[i][5] ? &atts[i][6] : NULL;
const unsigned char *namespace_name=atts[i+1];
raptor_namespace* nspace;
nspace=raptor_new_namespace(&sax2->namespaces,
prefix, namespace_name,
raptor_sax2_get_depth(sax2));
if(nspace) {
raptor_namespaces_start_namespace(&sax2->namespaces, nspace);
if(sax2->namespace_handler)
(*sax2->namespace_handler)(sax2->user_data, nspace);
}
} else if(!strcmp((char*)atts[i], "xml:lang")) {
xml_language=(unsigned char*)RAPTOR_MALLOC(cstring, strlen((char*)atts[i+1])+1);
if(!xml_language) {
raptor_log_error_to_handlers(sax2->world,
sax2->error_handlers,
RAPTOR_LOG_LEVEL_FATAL,
sax2->locator, "Out of memory");
goto fail;
}
/* optionally normalize language to lowercase */
if(sax2->feature_normalize_language) {
unsigned char *from=(unsigned char*)atts[i+1];
unsigned char *to=xml_language;
while(*from) {
if(isupper(*from))
*to++ =tolower(*from++);
else
*to++ =*from++;
}
*to='\0';
} else
strcpy((char*)xml_language, (char*)atts[i+1]);
} else if(!strcmp((char*)atts[i], "xml:base")) {
raptor_uri* base_uri;
raptor_uri* xuri;
base_uri=raptor_sax2_inscope_base_uri(sax2);
xuri=raptor_new_uri_relative_to_base_v2(sax2->world, base_uri, atts[i+1]);
xml_base=raptor_new_uri_for_xmlbase_v2(sax2->world, xuri);
raptor_free_uri_v2(sax2->world, xuri);
}
/* delete all xml attributes whether processed above or not */
atts[i]=NULL;
}
}
/* Create new element structure */
el_name=raptor_new_qname(&sax2->namespaces, name, NULL,
(raptor_simple_message_handler)raptor_sax2_simple_error, sax2);
if(!el_name)
goto fail;
xml_element=raptor_new_xml_element(el_name, xml_language, xml_base);
if(!xml_element) {
raptor_free_qname(el_name);
goto fail;
}
/* xml_language,xml_base now owned by xml_element */
xml_language = NULL;
xml_base = NULL;
/* Turn string attributes into namespaced-attributes */
if(ns_attributes_count) {
int i;
int offset = 0;
/* Allocate new array to hold namespaced-attributes */
named_attrs=(raptor_qname**)RAPTOR_CALLOC(raptor_qname_array,
ns_attributes_count,
sizeof(raptor_qname*));
if(!named_attrs) {
raptor_log_error_to_handlers(sax2->world,
sax2->error_handlers,
RAPTOR_LOG_LEVEL_FATAL,
sax2->locator, "Out of memory");
goto fail;
}
for (i = 0; i < all_atts_count; i++) {
raptor_qname* attr;
/* Skip previously processed attributes */
if(!atts[i<<1])
continue;
/* namespace-name[i] stored in named_attrs[i] */
attr=raptor_new_qname(&sax2->namespaces,
atts[i<<1], atts[(i<<1)+1],
(raptor_simple_message_handler)raptor_sax2_simple_error, sax2);
if(!attr) { /* failed - tidy up and return */
int j;
for (j=0; j < i; j++)
RAPTOR_FREE(raptor_qname, named_attrs[j]);
RAPTOR_FREE(raptor_qname_array, named_attrs);
goto fail;
}
named_attrs[offset++]=attr;
}
} /* end if ns_attributes_count */
if(named_attrs)
raptor_xml_element_set_attributes(xml_element,
named_attrs, ns_attributes_count);
raptor_xml_element_push(sax2, xml_element);
if(sax2->start_element_handler)
sax2->start_element_handler(sax2->user_data, xml_element);
if(xml_atts_copy) {
/* Restore passed in XML attributes, free the copy */
memcpy((void*)atts, xml_atts_copy, xml_atts_size);
RAPTOR_FREE(cstringpointer, xml_atts_copy);
}
return;
fail:
if(xml_atts_copy)
RAPTOR_FREE(cstringpointer, xml_atts_copy);
if(xml_base)
raptor_free_uri_v2(sax2->world, xml_base);
if(xml_language)
RAPTOR_FREE(cstring, xml_language);
if(xml_element)
raptor_free_xml_element(xml_element);
}
/*
* 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;
}
int
main(int argc, char *argv[])
{
raptor_world *world;
const char *program = raptor_basename(argv[0]);
raptor_iostream *iostr;
raptor_namespace_stack *nstack;
raptor_namespace* ex_ns;
raptor_turtle_writer* turtle_writer;
raptor_uri* base_uri;
raptor_qname* el_name;
unsigned long count;
raptor_uri* datatype;
/* for raptor_new_iostream_to_string */
void *string = NULL;
size_t string_len = 0;
world = raptor_new_world();
if(!world || raptor_world_open(world))
exit(1);
iostr = raptor_new_iostream_to_string(world, &string, &string_len, NULL);
if(!iostr) {
fprintf(stderr, "%s: Failed to create iostream to string\n", program);
exit(1);
}
nstack = raptor_new_namespaces(world, 1);
base_uri = raptor_new_uri(world, base_uri_string);
turtle_writer = raptor_new_turtle_writer(world, base_uri, 1, nstack, iostr);
if(!turtle_writer) {
fprintf(stderr, "%s: Failed to create turtle_writer to iostream\n", program);
exit(1);
}
raptor_turtle_writer_set_option(turtle_writer,
RAPTOR_OPTION_WRITER_AUTO_INDENT, 1);
ex_ns = raptor_new_namespace(nstack,
(const unsigned char*)"ex",
(const unsigned char*)"http://example.org/ns#",
0);
raptor_turtle_writer_namespace_prefix(turtle_writer, ex_ns);
raptor_turtle_writer_reference(turtle_writer, base_uri);
raptor_turtle_writer_increase_indent(turtle_writer);
raptor_turtle_writer_newline(turtle_writer);
raptor_turtle_writer_raw(turtle_writer, (const unsigned char*)"ex:foo ");
raptor_turtle_writer_quoted_counted_string(turtle_writer, longstr,
strlen((const char*)longstr));
raptor_turtle_writer_raw_counted(turtle_writer,
(const unsigned char*)" ;", 2);
raptor_turtle_writer_newline(turtle_writer);
el_name = raptor_new_qname_from_namespace_local_name(world,
ex_ns,
(const unsigned char*)"bar",
NULL);
raptor_turtle_writer_qname(turtle_writer, el_name);
raptor_free_qname(el_name);
raptor_turtle_writer_raw_counted(turtle_writer, (const unsigned char*)" ", 1);
datatype = raptor_new_uri(world, (const unsigned char*)"http://www.w3.org/2001/XMLSchema#decimal");
raptor_turtle_writer_literal(turtle_writer, nstack,
(const unsigned char*)"10.0", NULL,
datatype);
raptor_free_uri(datatype);
raptor_turtle_writer_newline(turtle_writer);
raptor_turtle_writer_decrease_indent(turtle_writer);
raptor_turtle_writer_raw_counted(turtle_writer, (const unsigned char*)".", 1);
raptor_turtle_writer_newline(turtle_writer);
raptor_free_turtle_writer(turtle_writer);
raptor_free_namespace(ex_ns);
raptor_free_namespaces(nstack);
raptor_free_uri(base_uri);
count = raptor_iostream_tell(iostr);
#if RAPTOR_DEBUG > 1
fprintf(stderr, "%s: Freeing iostream\n", program);
#endif
raptor_free_iostream(iostr);
if(count != OUT_BYTES_COUNT) {
fprintf(stderr, "%s: I/O stream wrote %d bytes, expected %d\n", program,
(int)count, (int)OUT_BYTES_COUNT);
fputs("[[", stderr);
(void)fwrite(string, 1, string_len, stderr);
fputs("]]\n", stderr);
return 1;
}
if(!string) {
fprintf(stderr, "%s: I/O stream failed to create a string\n", program);
return 1;
}
string_len = strlen((const char*)string);
if(string_len != count) {
fprintf(stderr, "%s: I/O stream created a string length %d, expected %d\n", program, (int)string_len, (int)count);
return 1;
}
#if RAPTOR_DEBUG > 1
fprintf(stderr, "%s: Made Turtle string of %d bytes\n", program, (int)string_len);
fputs("[[", stderr);
(void)fwrite(string, 1, string_len, stderr);
fputs("]]\n", stderr);
#endif
raptor_free_memory(string);
raptor_free_world(world);
/* keep gcc -Wall happy */
return(0);
}
/**
* 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;
}