/**
* raptor_print_ntriples_string:
* @stream: FILE* stream to print to
* @string: UTF-8 string to print
* @delim: Delimiter character for string (such as ") or \0 for no delim
* escaping.
*
* Print an UTF-8 string using N-Triples escapes.
*
* Return value: non-0 on failure such as bad UTF-8 encoding.
**/
int
raptor_print_ntriples_string(FILE *stream,
const unsigned char *string,
const char delim)
{
unsigned char c;
size_t len=strlen((const char*)string);
int unichar_len;
raptor_unichar unichar;
for(; (c=*string); string++, len--) {
if((delim && c == delim) || c == '\\') {
fprintf(stream, "\\%c", c);
continue;
}
/* Note: NTriples is ASCII */
if(c == 0x09) {
fputs("\\t", stream);
continue;
} else if(c == 0x0a) {
fputs("\\n", stream);
continue;
} else if(c == 0x0d) {
fputs("\\r", stream);
continue;
} else if(c < 0x20|| c == 0x7f) {
fprintf(stream, "\\u%04X", c);
continue;
} else if(c < 0x80) {
fputc(c, stream);
continue;
}
/* It is unicode */
unichar_len=raptor_utf8_to_unicode_char(NULL, string, len);
if(unichar_len < 0 || unichar_len > (int)len)
/* UTF-8 encoding had an error or ended in the middle of a string */
return 1;
unichar_len=raptor_utf8_to_unicode_char(&unichar, string, len);
if(unichar < 0x10000)
fprintf(stream, "\\u%04lX", unichar);
else
fprintf(stream, "\\U%08lX", unichar);
unichar_len--; /* since loop does len-- */
string += unichar_len; len -= unichar_len;
}
return 0;
}
/*
* raptor_ntriples_term - Parse an N-Triples term with escapes
* @parser: NTriples parser
* @start: pointer to starting character of string (in)
* @dest: destination of string (in)
* @lenp: pointer to length of string (in/out)
* @dest_lenp: pointer to length of destination string (out)
* @end_char: string ending character
* @class: string class
* @allow_utf8: Non-0 if UTF-8 chars are allowed in the term
*
* N-Triples strings/URIs are written in ASCII at present; characters
* outside the printable ASCII range are discarded with a warning.
* See the grammar for full details of the allowed ranges.
*
* If the class is RAPTOR_TERM_CLASS_FULL, the end_char is ignored.
*
* UTF-8 is only allowed if allow_utf8 is non-0, otherwise the
* string is US-ASCII and only the \u and \U esapes are allowed.
* If enabled, both are allowed.
*
* Return value: Non 0 on failure
**/
static int
raptor_ntriples_term(raptor_parser* rdf_parser,
const unsigned char **start, unsigned char *dest,
size_t *lenp, size_t *dest_lenp,
char end_char,
raptor_ntriples_term_class term_class,
int allow_utf8)
{
const unsigned char *p=*start;
unsigned char c='\0';
size_t ulen=0;
unsigned long unichar=0;
unsigned int position=0;
int end_char_seen=0;
if(term_class == RAPTOR_TERM_CLASS_FULL)
end_char='\0';
/* find end of string, fixing backslashed characters on the way */
while(*lenp > 0) {
c = *p;
p++;
(*lenp)--;
rdf_parser->locator.column++;
rdf_parser->locator.byte++;
if(allow_utf8) {
if(c > 0x7f) {
/* just copy the UTF-8 bytes through */
size_t unichar_len=raptor_utf8_to_unicode_char(NULL, (const unsigned char*)p-1, 1+*lenp);
if(unichar_len > *lenp) {
raptor_parser_error(rdf_parser, "UTF-8 encoding error at character %d (0x%02X) found.", c, c);
/* UTF-8 encoding had an error or ended in the middle of a string */
return 1;
}
memcpy(dest, p-1, unichar_len);
dest+= unichar_len;
unichar_len--; /* p, *lenp were moved on by 1 earlier */
p += unichar_len;
(*lenp) -= unichar_len;
rdf_parser->locator.column+= unichar_len;
rdf_parser->locator.byte+= unichar_len;
continue;
}
} else if(!IS_ASCII_PRINT(c)) {
/* This is an ASCII check, not a printable character check
* so isprint() is not appropriate, since that is a locale check.
*/
raptor_parser_error(rdf_parser, "Non-printable ASCII character %d (0x%02X) found.", c, c);
continue;
}
if(c != '\\') {
/* finish at non-backslashed end_char */
if(end_char && c == end_char) {
end_char_seen=1;
break;
}
if(!raptor_ntriples_term_valid(c, position, term_class)) {
if(end_char) {
/* end char was expected, so finding an invalid thing is an error */
raptor_parser_error(rdf_parser, "Missing terminating '%c' (found '%c')", end_char, c);
return 0;
} else {
/* it's the end - so rewind 1 to save next char */
p--;
(*lenp)++;
rdf_parser->locator.column--;
rdf_parser->locator.byte--;
break;
}
}
/* otherwise store and move on */
*dest++=c;
position++;
continue;
}
if(!*lenp) {
if(term_class != RAPTOR_TERM_CLASS_FULL)
raptor_parser_error(rdf_parser, "\\ at end of line");
return 0;
}
c = *p;
p++;
(*lenp)--;
rdf_parser->locator.column++;
rdf_parser->locator.byte++;
switch(c) {
case '"':
case '\\':
*dest++=c;
break;
case 'n':
*dest++='\n';
break;
case 'r':
*dest++='\r';
break;
case 't':
*dest++='\t';
break;
case 'u':
case 'U':
ulen=(c == 'u') ? 4 : 8;
if(*lenp < ulen) {
raptor_parser_error(rdf_parser, "%c over end of line", c);
return 0;
}
if(1) {
int n;
n=sscanf((const char*)p, ((ulen == 4) ? "%04lx" : "%08lx"), &unichar);
if(n != 1) {
raptor_parser_error(rdf_parser, "Illegal Uncode escape '%c%s...'", c, p);
break;
}
}
p+=ulen;
(*lenp)-=ulen;
rdf_parser->locator.column+=ulen;
rdf_parser->locator.byte+=ulen;
if(unichar > 0x10ffff) {
raptor_parser_error(rdf_parser, "Illegal Unicode character with code point #x%lX.", unichar);
break;
}
dest+=raptor_unicode_char_to_utf8(unichar, dest);
break;
default:
raptor_parser_error(rdf_parser,
"Illegal string escape \\%c in \"%s\"", c,
(char*)start);
return 0;
}
position++;
} /* end while */
if(end_char && !end_char_seen) {
raptor_parser_error(rdf_parser, "Missing terminating '%c' before end of line.", end_char);
return 1;
}
/* terminate dest, can be shorter than source */
*dest='\0';
if(dest_lenp)
*dest_lenp=p-*start;
*start=p;
return 0;
}
