/**
* raptor_sequence_join:
* @dest: #raptor_sequence destination sequence
* @src: #raptor_sequence source sequence
*
* Join two sequences moving all items from one sequence to the end of another.
*
* After this operation, sequence src will be empty (zero size) but
* will have the same item capacity as before.
*
* Return value: non-0 on failure
*/
int
raptor_sequence_join(raptor_sequence* dest, raptor_sequence *src)
{
RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(dest, raptor_sequence, 1);
RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(src, raptor_sequence, 1);
if(raptor_sequence_ensure(dest, dest->size + src->size, 0))
return 1;
memcpy(&dest->sequence[dest->start+dest->size], &src->sequence[src->start], sizeof(void*)*src->size);
dest->size += src->size;
src->size=0;
return 0;
}
/**
* raptor_sequence_size:
* @seq: sequence object
*
* Get the number of items in a sequence.
*
* Return value: the sequence size (>=0)
**/
int
raptor_sequence_size(raptor_sequence* seq)
{
RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(seq, raptor_sequence, -1);
return seq->size;
}
/**
* raptor_new_iostream_from_handler:
* @world: raptor_world object
* @user_data: pointer to context information to pass in to calls
* @handler: pointer to handler methods
*
* Create a new iostream over a user-defined handler
*
* Return value: new #raptor_iostream object or NULL on failure
**/
raptor_iostream*
raptor_new_iostream_from_handler(raptor_world *world,
void *user_data,
const raptor_iostream_handler* const handler)
{
raptor_iostream* iostr;
RAPTOR_CHECK_CONSTRUCTOR_WORLD(world);
RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(handler, raptor_iostream_handler, NULL);
raptor_world_open(world);
if(!raptor_iostream_check_handler(handler, 0))
return NULL;
iostr = RAPTOR_CALLOC(raptor_iostream*, 1, sizeof(*iostr));
if(!iostr)
return NULL;
iostr->world = world;
iostr->handler = handler;
iostr->user_data = (void*)user_data;
iostr->mode = raptor_iostream_calculate_modes(handler);
if(iostr->handler->init &&
iostr->handler->init(iostr->user_data)) {
RAPTOR_FREE(raptor_iostream, iostr);
return NULL;
}
return 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;
}
/**
* raptor_term_to_string:
* @term: #raptor_term
*
* Turns part of raptor statement into a N-Triples format string.
*
* Turns the given @term into an N-Triples escaped string using all the
* escapes as defined in http://www.w3.org/TR/rdf-testcases/#ntriples
*
* Return value: the new string or NULL on failure.
**/
unsigned char*
raptor_term_to_string(raptor_term *term)
{
RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(term, raptor_term, NULL);
return raptor_term_to_counted_string(term, NULL);
}
static int
raptor_sequence_ensure(raptor_sequence *seq, int capacity, int grow_at_front)
{
void **new_sequence;
int offset;
RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(seq, raptor_sequence, 1);
if(capacity && seq->capacity >= capacity)
return 0;
/* POLICY - minimum size */
if(capacity < 8)
capacity=8;
new_sequence=(void**)RAPTOR_CALLOC(ptrarray, capacity, sizeof(void*));
if(!new_sequence)
return 1;
offset=(grow_at_front ? (capacity-seq->capacity) : 0)+seq->start;
if(seq->size) {
memcpy(&new_sequence[offset], &seq->sequence[seq->start], sizeof(void*)*seq->size);
RAPTOR_FREE(ptrarray, seq->sequence);
}
seq->start=offset;
seq->sequence=new_sequence;
seq->capacity=capacity;
return 0;
}
/**
* raptor_term_to_counted_string:
* @term: #raptor_term
* @len_p: Pointer to location to store length of new string (if not NULL)
*
* Turns part of raptor term into a N-Triples format counted string.
*
* Turns the given @term into an N-Triples escaped string using all the
* escapes as defined in http://www.w3.org/TR/rdf-testcases/#ntriples
*
* This function uses raptor_term_ntriples_write() to write to an
* #raptor_iostream which is the prefered way to write formatted
* output.
*
* Return value: the new string or NULL on failure. The length of
* the new string is returned in *@len_p if len_p is not NULL.
**/
unsigned char*
raptor_term_to_counted_string(raptor_term *term, size_t* len_p)
{
raptor_iostream *iostr;
void *string = NULL;
int rc;
RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(term, raptor_term, NULL);
iostr = raptor_new_iostream_to_string(term->world,
&string, len_p, NULL);
if(!iostr)
return NULL;
rc = raptor_term_ntriples_write(term, iostr);
raptor_free_iostream(iostr);
if(rc) {
if(string) {
RAPTOR_FREE(cstring, string);
string = NULL;
}
}
return (unsigned char *)string;
}
/**
* raptor_sequence_get_at:
* @seq: sequence to use
* @idx: index of item to get
*
* Retrieve an item at offset @index in the sequence.
*
* This is efficient to perform. #raptor_sequence is optimised
* to append/remove from the end of the sequence.
*
* After this call the item is still owned by the sequence.
*
* Return value: the object or NULL if @index is out of range (0... sequence size-1)
**/
void*
raptor_sequence_get_at(raptor_sequence* seq, int idx)
{
RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(seq, raptor_sequence, NULL);
if(idx < 0 || idx > seq->size-1)
return NULL;
return seq->sequence[seq->start+idx];
}
/**
* raptor_world_is_serializer_name:
* @world: raptor_world object
* @name: the syntax name
*
* Check name of a serializer.
*
* Return value: non 0 if name is a known syntax name
*/
int
raptor_world_is_serializer_name(raptor_world* world, const char *name)
{
if(!name)
return 0;
RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(world, raptor_world, 0);
raptor_world_open(world);
return (raptor_get_serializer_factory(world, name) != NULL);
}
/**
* raptor_sequence_set_at:
* @seq: sequence object
* @idx: index into sequence to operate at
* @data: new data item.
*
* Replace/set an item in a sequence.
*
* The item at the offset @idx in the sequence is replaced with the
* new item @data (which may be NULL). Any existing item is freed
* with the sequence's free_handler. If necessary the sequence
* is extended (with NULLs) to handle a larger offset.
*
* The sequence takes ownership of the new data item. On failure, the
* item is freed immediately.
*
* Return value: non-0 on failure
**/
int
raptor_sequence_set_at(raptor_sequence* seq, int idx, void *data)
{
int need_capacity;
RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(seq, raptor_sequence, 1);
/* Cannot provide a negative index */
if(idx < 0) {
if(data) {
if(seq->free_handler)
seq->free_handler(data);
else if(seq->free_handler_v2)
seq->free_handler_v2(seq->handler_context, data);
}
return 1;
}
need_capacity=seq->start+idx+1;
if(need_capacity > seq->capacity) {
if(seq->capacity*2 > need_capacity)
need_capacity = seq->capacity*2;
if(raptor_sequence_ensure(seq, need_capacity, 0)) {
if(data) {
if(seq->free_handler)
seq->free_handler(data);
else if(seq->free_handler_v2)
seq->free_handler_v2(seq->handler_context, data);
}
return 1;
}
}
if(idx < seq->size) {
/* if there is old data, delete it if there is a free handler */
if(seq->sequence[seq->start+idx]) {
if(seq->free_handler)
seq->free_handler(seq->sequence[seq->start+idx]);
else if(seq->free_handler_v2)
seq->free_handler_v2(seq->handler_context, seq->sequence[seq->start+idx]);
}
/* size remains the same */
} else {
/* if there is no old data, size is increasing */
/* make sure there are seq->size items starting from seq->start */
seq->size=idx+1;
}
seq->sequence[seq->start+idx]=data;
return 0;
}
/**
* raptor_sequence_delete_at:
* @seq: sequence object
* @idx: index into sequence to operate at
*
* Remove an item from a position a sequence, returning it
*
* The item at the offset @idx in the sequence is replaced with a
* NULL pointer and any existing item is returned. The caller
* owns the resulting item.
*
* Return value: NULL on failure
**/
void*
raptor_sequence_delete_at(raptor_sequence* seq, int idx)
{
void* data;
RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(seq, raptor_sequence, NULL);
if(idx < 0 || idx > seq->size-1)
return NULL;
data=seq->sequence[seq->start+idx];
seq->sequence[seq->start+idx]=NULL;
return data;
}
/**
* raptor_world_get_serializer_description:
* @world: world object
* @counter: index into the list of serializers
*
* Get serializer descriptive syntax information
*
* Return value: description or NULL if counter is out of range
**/
const raptor_syntax_description*
raptor_world_get_serializer_description(raptor_world* world,
unsigned int counter)
{
raptor_serializer_factory *factory;
RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(world, raptor_world, NULL);
raptor_world_open(world);
factory = (raptor_serializer_factory*)raptor_sequence_get_at(world->serializers,
counter);
if(!factory)
return NULL;
return &factory->desc;
}
/**
* raptor_sequence_unshift:
* @seq: sequence to use
*
* Retrieve the item at the start of the sequence.
*
* Ownership of the item is transferred to the caller,
* i.e. caller is responsible of freeing the item.
*
* Return value: the object or NULL if the sequence is empty
**/
void*
raptor_sequence_unshift(raptor_sequence* seq)
{
void *data;
int i;
RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(seq, raptor_sequence, NULL);
if(!seq->size)
return NULL;
i=seq->start++;
data=seq->sequence[i];
seq->size--;
seq->sequence[i]=NULL;
return data;
}
int
raptor_term_print_as_ntriples(const raptor_term *term, FILE* stream)
{
int rc = 0;
raptor_iostream* iostr;
RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(term, raptor_term, 1);
RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(stream, FILE*, 1);
iostr = raptor_new_iostream_to_file_handle(term->world, stream);
if(!iostr)
return 1;
rc = raptor_term_ntriples_write(term, iostr);
raptor_free_iostream(iostr);
return rc;
}
/**
* raptor_sequence_shift:
* @seq: sequence to add to
* @data: item to add
*
* Add an item to the start of the sequence.
*
* The sequence takes ownership of the shifted item and frees it with the
* free_handler. On failure, the item is freed immediately.
*
* Return value: non-0 on failure
**/
int
raptor_sequence_shift(raptor_sequence* seq, void *data)
{
RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(seq, raptor_sequence, 1);
if(!seq->start) {
if(raptor_sequence_ensure(seq, seq->capacity*2, 1)) {
if(data) {
if(seq->free_handler)
seq->free_handler(data);
else if(seq->free_handler_v2)
seq->free_handler_v2(seq->handler_context, data);
}
return 1;
}
}
seq->sequence[--seq->start]=data;
seq->size++;
return 0;
}
/**
* raptor_get_serializer_factory:
* @world: raptor_world object
* @name: the factory name or NULL for the default factory
*
* Get a serializer factory by name.
*
* Return value: the factory object or NULL if there is no such factory
**/
static raptor_serializer_factory*
raptor_get_serializer_factory(raptor_world* world, const char *name)
{
raptor_serializer_factory *factory = NULL;
RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(world, raptor_world, NULL);
raptor_world_open(world);
/* return 1st serializer if no particular one wanted - why? */
if(!name) {
factory = (raptor_serializer_factory *)raptor_sequence_get_at(world->serializers, 0);
if(!factory) {
RAPTOR_DEBUG1("No (default) serializers registered\n");
return NULL;
}
} else {
int i;
for(i = 0;
(factory = (raptor_serializer_factory*)raptor_sequence_get_at(world->serializers, i));
i++) {
int namei;
const char* fname;
for(namei = 0; (fname = factory->desc.names[namei]); namei++) {
if(!strcmp(fname, name))
break;
}
if(fname)
break;
}
}
return factory;
}
/**
* raptor_xml_escape_string_any:
* @world: raptor world
* @string: string to XML escape (UTF-8)
* @len: length of string
* @buffer: the buffer to use for new string (UTF-8) or NULL to just calculate expected length
* @length: buffer size
* @quote: optional quote character to escape for attribute content, or 0
* @xml_version: XML 1.0 (10) or XML 1.1 (11)
*
* Return an XML-escaped version a string.
*
* Follows
* <ulink url="http://www.w3.org/TR/xml-c14n#ProcessingModel">Canonical XML rules on Text Nodes and Attribute Nodes</ulink>
*
* Both:
* Replaces <literal>&</literal> and <literal><</literal>
* with <literal>&amp;</literal> and <literal>&lt;</literal>
* respectively, preserving other characters.
*
* Text Nodes:
* <literal>></literal> is turned into <literal>&gt;</literal>
* ##xD is turned into <literal>&##xD;</literal>
*
* Attribute Nodes:
* <literal>></literal> is generated not <literal>&gt</literal>.
* ##x9, ##xA and ##xD are turned into
* <literal>&##x9;</literal>,
* <literal>&##xA;</literal> and
* <literal>&##xD;</literal>
* entities.
*
* If @quote is given it can be either of '\'' or '\"'
* which will be turned into <literal>&apos;</literal> or
* <literal>&quot;</literal> respectively.
* ASCII NUL ('\0') or any other character will not be escaped.
*
* If @buffer is NULL, no work is done but the size of buffer
* required is returned. The output in buffer remains in UTF-8.
*
* If the input @string is empty, a single NUL will be written to the
* buffer.
*
* Return value: the number of bytes required / used or <0 on failure.
**/
int
raptor_xml_escape_string_any(raptor_world *world,
const unsigned char *string, size_t len,
unsigned char *buffer, size_t length,
char quote,
int xml_version)
{
size_t l;
size_t new_len = 0;
const unsigned char *p;
unsigned char *q;
int unichar_len;
raptor_unichar unichar;
if(!string)
return -1;
RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(world, raptor_world, -1);
raptor_world_open(world);
if(quote != '\"' && quote != '\'')
quote='\0';
for(l = len, p = string; l; p++, l--) {
if(*p > 0x7f) {
unichar_len = raptor_unicode_utf8_string_get_char(p, l, &unichar);
if(unichar_len < 0 || RAPTOR_GOOD_CAST(size_t, unichar_len) > l) {
raptor_log_error(world, RAPTOR_LOG_LEVEL_ERROR, NULL,
"Bad UTF-8 encoding.");
return -1;
}
} else {
unichar=*p;
unichar_len = 1;
}
if(unichar == '&')
/* & */
new_len+= 5;
else if(unichar == '<' || (!quote && unichar == '>'))
/* < or > */
new_len+= 4;
else if(quote && unichar == (unsigned long)quote)
/* ' or " */
new_len+= 6;
else if(unichar == 0x0d ||
(quote && (unichar == 0x09 || unichar == 0x0a)))
/* 
 or 	 or &xA; */
new_len+= 5;
else if(unichar == 0x7f ||
(unichar < 0x20 && unichar != 0x09 && unichar != 0x0a)) {
if(!unichar || xml_version < 11) {
raptor_log_error_formatted(world, RAPTOR_LOG_LEVEL_ERROR, NULL,
"Cannot write illegal XML 1.0 character U+%6lX.",
unichar);
} else {
/* &#xX; */
new_len+= 5;
if(unichar > 0x0f)
new_len++;
}
} else
new_len+= unichar_len;
unichar_len--; /* since loop does len-- */
p += unichar_len; l -= unichar_len;
}
if(length && new_len > length)
return 0;
if(!buffer)
return RAPTOR_BAD_CAST(int, new_len);
for(l = len, p = string, q = buffer; l; p++, l--) {
if(*p > 0x7f) {
unichar_len = raptor_unicode_utf8_string_get_char(p, l, &unichar);
/* if the UTF-8 encoding is bad, we already did return -1 above */
} else {
unichar=*p;
unichar_len = 1;
}
if(unichar == '&') {
memcpy(q, "&", 5);
q+= 5;
} else if(unichar == '<') {
memcpy(q, "<", 4);
q+= 4;
} else if(!quote && unichar == '>') {
memcpy(q, ">", 4);
q+= 4;
} else if(quote && unichar == (unsigned long)quote) {
if(quote == '\'')
memcpy(q, "'", 6);
else
memcpy(q, """, 6);
q+= 6;
} else if(unichar == 0x0d ||
(quote && (unichar == 0x09 || unichar == 0x0a))) {
/* &#xX; */
*q++='&';
*q++='#';
*q++='x';
if(unichar == 0x09)
*q++ = '9';
else
*q++ = 'A'+ ((char)unichar-0x0a);
*q++= ';';
} else if(unichar == 0x7f ||
(unichar < 0x20 && unichar != 0x09 && unichar != 0x0a)) {
if(!unichar || xml_version < 11) {
raptor_log_error_formatted(world, RAPTOR_LOG_LEVEL_ERROR, NULL,
"Cannot write illegal XML 1.0 character U+%6lX.",
unichar);
} else {
/* &#xX; */
*q++ = '&';
*q++ = '#';
*q++ = 'x';
q += raptor_format_integer((char*)q, 3,
RAPTOR_GOOD_CAST(unsigned int, unichar),
/* base */ 16, -1, '\0');
*q++ = ';';
}
} else {
/* coverity[negative_returns]
* negative unichar_len values are checked and cause return -1 above */
memcpy(q, p, unichar_len);
q+= unichar_len;
}
unichar_len--; /* since loop does len-- */
p += unichar_len; l -= unichar_len;
}
