path: root/utils/rapper.c

/* -*- 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 long 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 %ld 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);
}