Permalink
Fetching contributors…
Cannot retrieve contributors at this time
973 lines (802 sloc) 28.2 KB
/* -*- Mode: c; c-basic-offset: 2 -*-
*
* rapper.c - Raptor RDF Parsing and Serializing utility
*
* Copyright (C) 2000-2010, David Beckett http://www.dajobe.org/
* Copyright (C) 2000-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>
/* Raptor includes */
#include <raptor2.h>
/* for access() and R_OK */
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef WIN32
#include <io.h>
#endif
/* many places for getopt */
#ifdef HAVE_GETOPT_H
#include <getopt.h>
#else
#include <raptor_getopt.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef NEED_OPTIND_DECLARATION
extern int optind;
extern char *optarg;
#endif
static void print_triples(void *user_data, raptor_statement *statement);
static void print_graph(void *user_data, raptor_uri *graph, int flags);
static void print_namespaces(void* user_data, raptor_namespace *nspace);
static void relay_namespaces(void* user_data, raptor_namespace *nspace);
int main(int argc, char *argv[]);
static char *program = NULL;
/* replace newlines in literal string output with spaces */
static int replace_newlines = 0;
/* extra noise? */
static int quiet = 0;
/* just count, no printing */
static int count = 0;
static int triple_count = 0;
static raptor_serializer* serializer = NULL;
static int guess = 0;
static int reported_guess = 0;
static int report_namespace = 0;
static int report_graph = 0;
static
void print_triples(void *user_data, raptor_statement *triple)
{
raptor_parser* rdf_parser = (raptor_parser*)user_data;
triple_count++;
if(guess && !quiet && !reported_guess) {
fprintf(stderr, "%s: Guessed parser name '%s'\n",
program, raptor_parser_get_name(rdf_parser));
reported_guess = 1;
}
if(count)
return;
/* replace newlines with spaces if object is a literal string */
if(replace_newlines &&
triple->object->type == RAPTOR_TERM_TYPE_LITERAL) {
char *s;
for(s = (char*)triple->object->value.literal.string; *s; s++)
if(*s == '\n')
*s=' ';
}
raptor_serializer_serialize_statement(serializer, triple);
return;
}
static
void print_graph(void *user_data, raptor_uri *graph, int flags)
{
/* raptor_parser *parser = (raptor_parser *)user_data; */
const char* const label = (flags & RAPTOR_GRAPH_MARK_START)
? (const char*)"start" : (const char*)"end";
if(!report_graph)
return;
if(graph)
fprintf(stderr, "%s: Graph URI %s %s\n",
program, raptor_uri_as_string(graph), label);
else
fprintf(stderr, "%s: Default graph %s\n",
program, label);
}
static void
print_namespaces(void* user_data, raptor_namespace *nspace)
{
/* raptor_parser* rdf_parser = (raptor_parser*)user_data; */
unsigned char *s;
if(!report_namespace)
return;
s = raptor_namespace_format_as_xml(nspace, NULL);
fprintf(stderr, "%s: Namespace declared: %s\n",
program, s);
raptor_free_memory(s);
return;
}
static void
relay_namespaces(void* user_data, raptor_namespace *nspace)
{
raptor_serializer* rdf_serializer = (raptor_serializer*)user_data;
if(report_namespace)
print_namespaces(user_data, nspace);
raptor_serializer_set_namespace_from_namespace(rdf_serializer, nspace);
}
#ifdef HAVE_GETOPT_LONG
#define HELP_TEXT(short, long, description) " -" short ", --" long " " description
#define HELP_TEXT_LONG(long, description) " --" long " " description
#define HELP_ARG(short, long) "--" #long
#define HELP_ARG_BOTH(short, long) " \"-" short "\" or \"--" long "\""
#define HELP_PAD "\n "
#else
#define HELP_TEXT(short, long, description) " -" short " " description
#define HELP_TEXT_LONG(long, description)
#define HELP_ARG(short, long) "-" #short
#define HELP_ARG_BOTH(short, long) "\"-" short "\""
#define HELP_PAD "\n "
#endif
#define GETOPT_STRING "cef:ghi:I:o:O:qrtvw"
#ifdef HAVE_GETOPT_LONG
#define SHOW_NAMESPACES_FLAG 0x100
#define SHOW_GRAPHS_FLAG 0x200
static const struct option long_options[] =
{
/* name, has_arg, flag, val */
{"count", 0, 0, 'c'},
{"ignore-errors", 0, 0, 'e'},
{"feature", 1, 0, 'f'},
{"guess", 0, 0, 'g'},
{"help", 0, 0, 'h'},
{"input", 1, 0, 'i'},
{"input-uri", 1, 0, 'I'},
{"output", 1, 0, 'o'},
{"output-uri", 1, 0, 'O'},
{"quiet", 0, 0, 'q'},
{"replace-newlines", 0, 0, 'r'},
{"show-graphs", 0, 0, SHOW_GRAPHS_FLAG},
{"show-namespaces", 0, 0, SHOW_NAMESPACES_FLAG},
{"trace", 0, 0, 't'},
{"version", 0, 0, 'v'},
{"ignore-warnings", 0, 0, 'w'},
{NULL, 0, 0, 0}
};
#endif
static int error_count = 0;
static int warning_count = 0;
static int ignore_warnings = 0;
static int ignore_errors = 0;
static const char * const title_string =
"Raptor RDF syntax parsing and serializing utility";
static void
rapper_log_handler(void *data, raptor_log_message *message)
{
raptor_parser *parser = (raptor_parser *)data;
switch(message->level) {
case RAPTOR_LOG_LEVEL_FATAL:
case RAPTOR_LOG_LEVEL_ERROR:
if(!ignore_errors) {
fprintf(stderr, "%s: Error - ", program);
raptor_locator_print(message->locator, stderr);
fprintf(stderr, " - %s\n", message->text);
raptor_parser_parse_abort(parser);
}
error_count++;
break;
case RAPTOR_LOG_LEVEL_WARN:
if(!ignore_warnings) {
fprintf(stderr, "%s: Warning - ", program);
raptor_locator_print(message->locator, stderr);
fprintf(stderr, " - %s\n", message->text);
}
warning_count++;
break;
case RAPTOR_LOG_LEVEL_NONE:
case RAPTOR_LOG_LEVEL_TRACE:
case RAPTOR_LOG_LEVEL_DEBUG:
case RAPTOR_LOG_LEVEL_INFO:
fprintf(stderr, "%s: Unexpected %s message - ", program,
raptor_log_level_get_label(message->level));
raptor_locator_print(message->locator, stderr);
fprintf(stderr, " - %s\n", message->text);
break;
}
}
struct namespace_decl
{
unsigned char *prefix;
unsigned char *uri_string;
};
static void
rapper_free_namespace_decl(void* data) {
struct namespace_decl* nsd = (struct namespace_decl*)data;
if(nsd->prefix)
raptor_free_memory(nsd->prefix);
if(nsd->uri_string)
raptor_free_memory(nsd->uri_string);
raptor_free_memory(nsd);
}
static int
rapper_uri_trace(void *user_data, raptor_uri* uri)
{
fprintf(stderr, "%s: Tracing retrieval of URI %s\n",
program, raptor_uri_as_string(uri));
return 0;
}
typedef struct
{
raptor_option option;
int i_value;
const char* s_value;
} option_value;
int
main(int argc, char *argv[])
{
/* input variables - parser
* 'uri_string' is set to a URI otherwise 'filename' is file name
* or if NULL, stdin. Base URI in 'base_uri_string' is required for stdin.
*/
raptor_world* world = NULL;
raptor_parser* rdf_parser = NULL;
char *filename = NULL;
#define FILENAME_LABEL(name) ((name) ? (name) : "<stdin>")
unsigned char *uri_string = NULL;
int free_uri_string = 0;
raptor_uri *uri;
unsigned char *base_uri_string = NULL;
raptor_uri *base_uri = NULL;
const char *syntax_name="rdfxml";
raptor_sequence* parser_options = NULL;
int trace = 0;
/* output variables - serializer */
/* 'serializer' object variable is a global */
const char *serializer_syntax_name = "ntriples";
const unsigned char *output_base_uri_string = NULL;
raptor_uri *output_base_uri = NULL;
raptor_sequence* serializer_options = NULL;
raptor_sequence *namespace_declarations = NULL;
/* other variables */
int rc;
int usage = 0;
int help = 0;
char *p;
program = argv[0];
if((p = strrchr(program, '/')))
program = p + 1;
else if((p = strrchr(program, '\\')))
program = p + 1;
argv[0] = program;
world = raptor_new_world();
if(!world)
exit(1);
rc = raptor_world_open(world);
if(rc)
exit(1);
while(!usage && !help)
{
int c;
#ifdef HAVE_GETOPT_LONG
int option_index = 0;
c = getopt_long (argc, argv, GETOPT_STRING, long_options, &option_index);
#else
c = getopt (argc, argv, GETOPT_STRING);
#endif
if(c == -1)
break;
switch (c) {
case 0:
case '?': /* getopt() - unknown option */
usage = 1;
break;
case 'c':
count = 1;
if(serializer_syntax_name)
serializer_syntax_name = NULL;
break;
case 'f':
if(optarg) {
if(!strcmp(optarg, "help")) {
int option_count = (int)raptor_option_get_count();
int i;
fprintf(stderr, "%s: Valid parser options are:\n",
program);
for(i = 0; i < option_count; i++) {
raptor_option_description *od;
od = raptor_world_get_option_description(world,
RAPTOR_DOMAIN_PARSER,
(raptor_option)i);
if(od) {
fprintf(stderr, " %-21s %s (%s)\n",
od->name, od->label,
raptor_option_get_value_type_label(od->value_type));
}
}
fprintf(stderr, "%s: Valid serializer options are:\n",
program);
for(i = 0; i < option_count; i++) {
raptor_option_description *od;
od = raptor_world_get_option_description(world,
RAPTOR_DOMAIN_SERIALIZER,
(raptor_option)i);
if(od) {
fprintf(stderr, " %-21s %s (%s)\n",
od->name, od->label,
raptor_option_get_value_type_label(od->value_type));
raptor_free_option_description(od);
}
}
fputs("Options are set with `" HELP_ARG(f, option) " OPTION = VALUE or `-f OPTION'\n"
"and take a decimal integer VALUE except where noted, defaulting to 1 if omitted.\n", stderr);
fputs("\nA option of the form xmlns:PREFIX=\"URI\" can be used to declare output\n"
"namespace prefixes and names for serializing using an XML-style syntax\n"
"Either or both of PREFIX or URI can be omitted such as -f xmlns=\"URI\"\n"
"This form can be repeated for multiple declarations.\n",
stderr);
raptor_free_world(world);
exit(0);
} else if(!strncmp(optarg, "xmlns", 5)) {
struct namespace_decl *nd;
nd = (struct namespace_decl *)raptor_alloc_memory(sizeof(*nd));
if(raptor_xml_namespace_string_parse((unsigned char*)optarg,
&nd->prefix,
&nd->uri_string)) {
fprintf(stderr, "%s: Bad xmlns syntax in '%s'\n",
program, optarg);
rapper_free_namespace_decl(nd);
raptor_free_world(world);
exit(0);
}
if(!namespace_declarations)
namespace_declarations = raptor_new_sequence(rapper_free_namespace_decl, NULL);
raptor_sequence_push(namespace_declarations, nd);
} else {
int option_count = (int)raptor_option_get_count();
int i;
size_t arg_len = strlen(optarg);
option_value* fv;
int ok = 0;
/* parser options */
for(i = 0; i < option_count; i++) {
raptor_domain domain;
raptor_option_description *od;
size_t name_len;
domain = RAPTOR_DOMAIN_PARSER;
od = raptor_world_get_option_description(world,
domain,
(raptor_option)i);
if(!od) {
domain = RAPTOR_DOMAIN_SERIALIZER;
od = raptor_world_get_option_description(world,
domain,
(raptor_option)i);
if(!od)
/* Neither a parser or serializer option - skip */
continue;
}
name_len = od->name_len;
if(!strncmp(optarg, od->name, name_len)) {
fv = (option_value*)raptor_calloc_memory(sizeof(option_value),
1);
fv->option = (raptor_option)i;
if(od->value_type == RAPTOR_OPTION_VALUE_TYPE_BOOL ||
od->value_type == RAPTOR_OPTION_VALUE_TYPE_INT) {
if(name_len < arg_len && optarg[name_len] == '=')
fv->i_value = atoi(&optarg[name_len + 1]);
else if(name_len == arg_len)
fv->i_value = 1;
} else {
if(name_len < arg_len && optarg[name_len] == '=')
fv->s_value = &optarg[name_len + 1];
else if(name_len == arg_len)
fv->s_value = (const char*)"";
}
if(domain == RAPTOR_DOMAIN_PARSER) {
if(!parser_options)
parser_options = raptor_new_sequence(raptor_free_memory,
NULL);
raptor_sequence_push(parser_options, fv);
} else {
/* RAPTOR_DOMAIN_SERIALIZER */
if(!serializer_options)
serializer_options = raptor_new_sequence(raptor_free_memory,
NULL);
raptor_sequence_push(serializer_options, fv);
}
ok = 1;
}
raptor_free_option_description(od);
if(ok)
break;
}
if(!ok) {
fprintf(stderr,
"%s: invalid argument `%s' for `" HELP_ARG(f, option) "'\n"
"Try '%s " HELP_ARG(f, option) " help' for a list of valid options\n",
program, optarg, program);
usage = 1;
}
}
}
break;
case 'g':
guess = 1;
break;
case 'h':
help = 1;
break;
case 't':
trace = 1;
break;
case 'q':
quiet = 1;
break;
case 'r':
replace_newlines = 1;
break;
case 'o':
if(optarg) {
if(raptor_world_is_serializer_name(world, optarg))
serializer_syntax_name = optarg;
else {
int i;
fprintf(stderr,
"%s: invalid argument `%s' for `" HELP_ARG(o, output) "'\n",
program, optarg);
fprintf(stderr, "Valid arguments are:\n");
for(i = 0; 1; i++) {
const raptor_syntax_description* sd;
sd = raptor_world_get_serializer_description(world, i);
if(!sd)
break;
fprintf(stderr, " %-14s for %s\n", sd->names[0], sd->label);
}
usage = 1;
break;
}
}
break;
case 'O':
if(optarg)
output_base_uri_string = (const unsigned char*)optarg;
break;
case 'i':
if(optarg) {
if(raptor_world_is_parser_name(world, optarg))
syntax_name = optarg;
else {
int i;
fprintf(stderr,
"%s: invalid argument `%s' for `" HELP_ARG(i, input) "'\n",
program, optarg);
fprintf(stderr, "Valid arguments are:\n");
for(i = 0; 1; i++) {
const raptor_syntax_description* sd;
sd = raptor_world_get_parser_description(world, i);
if(!sd)
break;
fprintf(stderr, " %-14s for %s\n", sd->names[0], sd->label);
}
usage = 1;
break;
}
}
break;
case 'I':
if(optarg)
base_uri_string = (unsigned char*)optarg;
break;
case 'w':
ignore_warnings = 1;
break;
case 'e':
ignore_errors = 1;
break;
case 'v':
fputs(raptor_version_string, stdout);
fputc('\n', stdout);
raptor_free_world(world);
exit(0);
#ifdef SHOW_NAMESPACES_FLAG
case SHOW_NAMESPACES_FLAG:
report_namespace = 1;
break;
#endif
#ifdef SHOW_GRAPHS_FLAG
case SHOW_GRAPHS_FLAG:
report_graph = 1;
break;
#endif
} /* end switch */
}
if(optind != argc-1 && optind != argc-2 && !help && !usage) {
usage = 2; /* Title and usage */
}
if(usage) {
if(usage > 1) {
fputs(title_string, stderr); putc(' ', stderr); fputs(raptor_version_string, stderr); putc('\n', stderr);
fputs("Raptor home page: ", stderr);
fputs(raptor_home_url_string, stderr);
fputc('\n', stderr);
fputs(raptor_copyright_string, stderr);
fputs("\nLicense: ", stderr);
fputs(raptor_license_string, stderr);
fputs("\n\n", stderr);
}
fprintf(stderr, "Try `%s " HELP_ARG(h, help) "' for more information.\n",
program);
raptor_free_world(world);
exit(1);
}
if(help) {
int i;
puts(title_string); putchar(' '); puts(raptor_version_string); putchar('\n');
puts("Parse RDF syntax from a source into serialized RDF triples.");
printf("Usage: %s [OPTIONS] INPUT-URI [INPUT-BASE-URI]\n\n", program);
fputs(raptor_copyright_string, stdout);
fputs("\nLicense: ", stdout);
puts(raptor_license_string);
fputs("Raptor home page: ", stdout);
puts(raptor_home_url_string);
puts("\nArguments:");
puts(" INPUT-URI a filename, URI or '-' for standard input (stdin).");
puts(" INPUT-BASE-URI the input/parser base URI or '-' for none.\n"
" Default is INPUT-URI\n"
" Equivalent to" HELP_ARG_BOTH("I INPUT-BASE-URI", "input-uri INPUT-BASE-URI"));
puts("\nMain options:");
puts(HELP_TEXT("i FORMAT", "input FORMAT ", "Set the input format/parser to one of:"));
for(i = 0; 1; i++) {
const raptor_syntax_description* sd;
sd = raptor_world_get_parser_description(world, i);
if(!sd)
break;
printf(" %-14s %s", sd->names[0], sd->label);
if(!i)
puts(" (default)");
else
putchar('\n');
}
puts(HELP_TEXT("I URI", "input-uri URI ", "Set the input/parser base URI. '-' for none.") HELP_PAD " Default is INPUT-BASE-URI argument value.");
putchar('\n');
puts(HELP_TEXT("o FORMAT", "output FORMAT", "Set the output format/serializer to one of:"));
for(i = 0; 1; i++) {
const raptor_syntax_description* sd;
sd = raptor_world_get_serializer_description(world, i);
if(!sd)
break;
printf(" %-14s %s", sd->names[0], sd->label);
if(!i)
puts(" (default)");
else
putchar('\n');
}
puts(HELP_TEXT("O URI", "output-uri URI ", "Set the output/serializer base URI. '-' for none.") HELP_PAD " Default is input/parser base URI.");
putchar('\n');
puts("General options:");
puts(HELP_TEXT("c", "count ", "Count triples only - do not print them."));
puts(HELP_TEXT("e", "ignore-errors ", "Ignore error messages"));
puts(HELP_TEXT("f OPTION(=VALUE)", "feature OPTION(=VALUE)", HELP_PAD "Set parser or serializer options" HELP_PAD "Use `-f help' for a list of valid options"));
puts(HELP_TEXT("g", "guess ", "Guess the input syntax (same as -i guess)"));
puts(HELP_TEXT("h", "help ", "Print this help, then exit"));
puts(HELP_TEXT("q", "quiet ", "No extra information messages"));
puts(HELP_TEXT("r", "replace-newlines", "Replace newlines with spaces in literals"));
#ifdef SHOW_GRAPHS_FLAG
puts(HELP_TEXT_LONG("show-graphs ", "Show named graphs as they are declared"));
#endif
#ifdef SHOW_NAMESPACES_FLAG
puts(HELP_TEXT_LONG("show-namespaces ", "Show namespaces as they are declared"));
#endif
puts(HELP_TEXT("t", "trace ", "Trace URIs retrieved during parsing"));
puts(HELP_TEXT("w", "ignore-warnings ", "Ignore warning messages"));
puts(HELP_TEXT("v", "version ", "Print the Raptor version"));
puts("\nReport bugs to http://bugs.librdf.org/");
raptor_free_world(world);
exit(0);
}
if(optind == argc-1)
uri_string = (unsigned char*)argv[optind];
else {
uri_string = (unsigned char*)argv[optind++];
base_uri_string = (unsigned char*)argv[optind];
}
/* If uri_string is "path-to-file", turn it into a file: URI */
if(!strcmp((const char*)uri_string, "-")) {
if(!base_uri_string) {
fprintf(stderr,
"%s: A Base URI is required when reading from standard input.\n",
program);
return(1);
}
uri_string = NULL;
} else if(!access((const char*)uri_string, R_OK)) {
filename = (char*)uri_string;
uri_string = raptor_uri_filename_to_uri_string(filename);
if(!uri_string) {
fprintf(stderr, "%s: Failed to create URI for file %s.\n",
program, filename);
return(1);
}
free_uri_string = 1;
}
if(uri_string) {
uri = raptor_new_uri(world, uri_string);
if(!uri) {
fprintf(stderr, "%s: Failed to create URI for %s\n",
program, uri_string);
return(1);
}
} else
uri = NULL; /* stdin */
/* Set the input/parser base URI */
if(base_uri_string) {
if(strcmp((const char*)base_uri_string, "-")) {
base_uri = raptor_new_uri(world, base_uri_string);
if(!base_uri) {
fprintf(stderr, "%s: Failed to create URI for %s\n",
program, base_uri_string);
return(1);
}
}
}
/* Set the output/serializer base URI from the argument if explicitly
* set, otherwise default to the input base URI if present.
*/
if(!output_base_uri_string) {
if(base_uri)
output_base_uri = raptor_uri_copy(base_uri);
} else {
if(strcmp((const char*)output_base_uri_string, "-")) {
output_base_uri = raptor_new_uri(world, output_base_uri_string);
if(!output_base_uri) {
fprintf(stderr, "%s: Failed to create output base URI for %s\n",
program, output_base_uri_string);
return(1);
}
} else
output_base_uri = NULL;
}
if(guess)
syntax_name="guess";
rdf_parser = raptor_new_parser(world, syntax_name);
if(!rdf_parser) {
fprintf(stderr, "%s: Failed to create raptor parser type %s\n",
program, syntax_name);
return(1);
}
raptor_world_set_log_handler(world, rdf_parser, rapper_log_handler);
if(parser_options) {
option_value *fv;
while((fv = (option_value*)raptor_sequence_pop(parser_options))) {
raptor_parser_set_option(rdf_parser, fv->option,
fv->s_value, fv->i_value);
raptor_free_memory(fv);
}
raptor_free_sequence(parser_options);
parser_options = NULL;
}
if(trace)
raptor_parser_set_uri_filter(rdf_parser, rapper_uri_trace, rdf_parser);
if(!quiet) {
if(uri_string) {
if(base_uri_string)
fprintf(stderr, "%s: Parsing URI %s with parser %s and base URI %s\n",
program, uri_string, syntax_name, base_uri_string);
else
fprintf(stderr, "%s: Parsing URI %s with parser %s\n", program,
uri_string, syntax_name);
} else {
if(base_uri_string)
fprintf(stderr,
"%s: Parsing file %s with parser %s and base URI %s\n", program,
FILENAME_LABEL(filename), syntax_name, base_uri_string);
else
fprintf(stderr, "%s: Parsing file %s with parser %s\n", program,
FILENAME_LABEL(filename), syntax_name);
}
}
raptor_parser_set_statement_handler(rdf_parser, rdf_parser, print_triples);
if(report_graph)
raptor_parser_set_graph_mark_handler(rdf_parser, rdf_parser, print_graph);
if(report_namespace)
raptor_parser_set_namespace_handler(rdf_parser, rdf_parser,
print_namespaces);
if(serializer_syntax_name) {
if(!quiet) {
if(output_base_uri)
fprintf(stderr, "%s: Serializing with serializer %s and base URI %s\n",
program, serializer_syntax_name,
raptor_uri_as_string(output_base_uri));
else
fprintf(stderr, "%s: Serializing with serializer %s\n",
program, serializer_syntax_name);
}
serializer = raptor_new_serializer(world, serializer_syntax_name);
if(!serializer) {
fprintf(stderr,
"%s: Failed to create raptor serializer type %s\n", program,
serializer_syntax_name);
return(1);
}
if(namespace_declarations) {
int i;
for(i = 0; i< raptor_sequence_size(namespace_declarations); i++) {
struct namespace_decl *nd;
raptor_uri *ns_uri = NULL;
nd = (struct namespace_decl*)raptor_sequence_get_at(namespace_declarations, i);
if(nd->uri_string)
ns_uri = raptor_new_uri(world, nd->uri_string);
raptor_serializer_set_namespace(serializer, ns_uri, nd->prefix);
if(ns_uri)
raptor_free_uri(ns_uri);
}
raptor_free_sequence(namespace_declarations);
namespace_declarations = NULL;
}
if(serializer_options) {
option_value *fv;
while((fv = (option_value*)raptor_sequence_pop(serializer_options))) {
raptor_serializer_set_option(serializer, fv->option,
fv->s_value, fv->i_value);
raptor_free_memory(fv);
}
raptor_free_sequence(serializer_options);
serializer_options = NULL;
}
raptor_serializer_start_to_file_handle(serializer,
output_base_uri, stdout);
if(!report_namespace)
raptor_parser_set_namespace_handler(rdf_parser, serializer,
relay_namespaces);
}
/* Begin the parsing of the content from file or URI,
* sending it to serializer via callback print_triples()
*/
rc = 0;
if(!uri || filename) {
if(raptor_parser_parse_file(rdf_parser, uri, base_uri)) {
fprintf(stderr, "%s: Failed to parse file %s %s content\n",
program, FILENAME_LABEL(filename), syntax_name);
rc = 1;
}
} else {
if(raptor_parser_parse_uri(rdf_parser, uri, base_uri)) {
fprintf(stderr, "%s: Failed to parse URI %s %s content\n",
program, uri_string, syntax_name);
rc = 1;
}
}
raptor_free_parser(rdf_parser);
if(serializer) {
raptor_serializer_serialize_end(serializer);
raptor_free_serializer(serializer);
}
if(!quiet) {
if(triple_count == 1)
fprintf(stderr, "%s: Parsing returned 1 triple\n",
program);
else
fprintf(stderr, "%s: Parsing returned %d triples\n",
program, triple_count);
}
if(output_base_uri)
raptor_free_uri(output_base_uri);
if(base_uri)
raptor_free_uri(base_uri);
if(uri)
raptor_free_uri(uri);
if(free_uri_string)
raptor_free_memory(uri_string);
if(namespace_declarations)
raptor_free_sequence(namespace_declarations);
if(parser_options)
raptor_free_sequence(parser_options);
if(serializer_options)
raptor_free_sequence(serializer_options);
raptor_free_world(world);
if(error_count && !ignore_errors)
return 1;
if(warning_count && !ignore_warnings)
return 2;
return(rc);
}