/* ..._start and ..._finish share an int * count parameter
* the same variable should be passed by reference both times */
int fs_import_stream_start(fsp_link *link, const char *model_uri, const char *mimetype, int has_o_index, int *count)
{
if (inited == 0) {
memset(&parse_data, 0, sizeof(parse_data));
inited = 1;
}
parse_data.link = link;
parse_data.segments = fsp_link_segments(link);
parse_data.ext_count = count;
for (int i=0; i<parse_data.segments; i++) {
for (int j=0; j<RES_BUF_SIZE; j++) {
lex_tmp[i][j] = malloc(RES_BUF_SIZE);
}
}
memset(nodecache, 0, sizeof(nodecache));
parse_data.quad_fn = g_strdup(FS_TMP_PATH "/importXXXXXX");
parse_data.quad_fd = mkstemp(parse_data.quad_fn);
if (parse_data.quad_fd < 0) {
fs_error(LOG_ERR, "Cannot create tmp file “%s”", parse_data.quad_fn);
return 1;
}
parse_data.muri = raptor_new_uri((unsigned char *) model_uri);
parse_data.model = g_strdup(model_uri);
parse_data.model_hash = fs_hash_uri(model_uri);
parse_data.count_trip = 0;
parse_data.count_err = 0;
parse_data.last_count = 0;
parse_data.has_o_index = has_o_index;
/* store the model uri */
buffer_res(link, parse_data.segments, parse_data.model_hash, parse_data.model, FS_RID_NULL, parse_data.dryrun);
parse_data.parser = raptor_new_parser_for_content(NULL, mimetype, NULL, 0, (unsigned char *) parse_data.model);
if (!parse_data.parser) {
return 1;
}
/* use us as a vector for an indirect attack? no thanks */
raptor_set_feature(parse_data.parser, RAPTOR_FEATURE_NO_NET, 0);
raptor_set_fatal_error_handler(parse_data.parser, link, fatal_rdf_parser_error);
raptor_set_error_handler(parse_data.parser, link, rdf_parser_error);
raptor_set_statement_handler(parse_data.parser, &parse_data, store_stmt);
raptor_set_graph_handler(parse_data.parser, &parse_data, graph_handler);
raptor_start_parse(parse_data.parser, parse_data.muri);
fs_hash_freshen(); /* blank nodes are unique per file */
return 0;
}
int
main(int argc, char *argv[])
{
raptor_parser* rdf_parser=NULL;
unsigned char *uri_string=NULL;
int free_uri_string=0;
unsigned char *base_uri_string=NULL;
int rc;
int scanning=0;
const char *syntax_name="rdfxml";
int strict_mode=0;
int usage=0;
int help=0;
raptor_uri *base_uri;
raptor_uri *uri;
char *p;
char *filename=NULL;
program=argv[0];
if((p=strrchr(program, '/')))
program=p+1;
else if((p=strrchr(program, '\\')))
program=p+1;
argv[0]=program;
raptor_init();
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 'a':
break;
case 'c':
count=1;
break;
case 'h':
help=1;
break;
case 'n':
syntax_name="ntriples";
break;
case 's':
scanning=1;
break;
case 'q':
quiet=1;
break;
case 'r':
replace_newlines=1;
break;
case 'm':
if(optarg) {
if(!strcmp(optarg, "strict"))
strict_mode=1;
else if (!strcmp(optarg, "lax"))
strict_mode=0;
else {
fprintf(stderr, "%s: invalid argument `%s' for `" HELP_ARG(m, mode) "'\n",
program, optarg);
fprintf(stderr, "Valid arguments are:\n - `lax'\n - `strict'\n");
usage=1;
}
}
break;
case 'o':
if(optarg) {
if(!strcmp(optarg, "simple"))
output_format=OUTPUT_FORMAT_SIMPLE;
else if (!strcmp(optarg, "ntriples"))
output_format=OUTPUT_FORMAT_NTRIPLES;
else {
fprintf(stderr, "%s: invalid argument `%s' for `" HELP_ARG(o, output) "'\n",
program, optarg);
fprintf(stderr, "Valid arguments are:\n `simple' for a simple format (default)\n `ntriples' for N-Triples\n");
usage=1;
}
}
break;
case 'i':
if(optarg) {
if(raptor_syntax_name_check(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 char *help_name;
const char *help_label;
if(raptor_syntaxes_enumerate(i, &help_name, &help_label, NULL, NULL))
break;
printf(" %-12s for %s\n", help_name, help_label);
}
usage=1;
break;
}
}
break;
case 'w':
ignore_warnings=1;
break;
case 'e':
ignore_errors=1;
break;
case 'v':
fputs(raptor_version_string, stdout);
fputc('\n', stdout);
exit(0);
}
}
if(optind != argc-1 && optind != argc-2 && !help && !usage) {
usage=2; /* Title and usage */
}
if(usage) {
if(usage>1) {
fprintf(stderr, title_format_string, raptor_version_string);
fputs(raptor_short_copyright_string, stderr);
fputc('\n', stderr);
}
fprintf(stderr, "Try `%s " HELP_ARG(h, help) "' for more information.\n",
program);
exit(1);
}
if(help) {
int i;
printf("Usage: %s [OPTIONS] <source URI> [base URI]\n", program);
printf(title_format_string, raptor_version_string);
puts(raptor_short_copyright_string);
puts("Parse RDF content at the source URI into RDF triples.");
puts("\nMain options:");
puts(HELP_TEXT(h, "help ", "Print this help, then exit"));
puts(HELP_TEXT(i, "input FORMAT ", "Set input format to one of:"));
for(i=0; 1; i++) {
const char *help_name;
const char *help_label;
if(raptor_syntaxes_enumerate(i, &help_name, &help_label, NULL, NULL))
break;
printf(" %-12s %s", help_name, help_label);
if(!i)
puts(" (default)");
else
putchar('\n');
}
puts(HELP_TEXT(o, "output FORMAT ", "Set output format to one of:"));
puts(" 'simple' A simple format (default)\n 'ntriples' N-Triples");
puts(HELP_TEXT(m, "mode MODE ", "Set parser mode - 'lax' (default) or 'strict'"));
puts("\nAdditional options:");
puts(HELP_TEXT(c, "count ", "Count triples - no output"));
puts(HELP_TEXT(e, "ignore-errors ", "Ignore error messages"));
puts(HELP_TEXT(q, "quiet ", "No extra information messages"));
puts(HELP_TEXT(r, "replace-newlines", "Replace newlines with spaces in literals"));
puts(HELP_TEXT(s, "scan ", "Scan for <rdf:RDF> element in source"));
puts(HELP_TEXT(w, "ignore-warnings ", "Ignore warning messages"));
puts(HELP_TEXT(v, "version ", "Print the Raptor version"));
puts("\nReport bugs to <*****@*****.**>.");
puts("Raptor home page: http://www.redland.opensource.ac.uk/raptor/");
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);
free_uri_string=1;
}
if(uri_string) {
uri=raptor_new_uri(uri_string);
if(!uri) {
fprintf(stderr, "%s: Failed to create URI for %s\n",
program, uri_string);
return(1);
}
} else
uri=NULL; /* stdin */
if(!base_uri_string) {
base_uri=raptor_uri_copy(uri);
} else {
base_uri=raptor_new_uri(base_uri_string);
if(!base_uri) {
fprintf(stderr, "%s: Failed to create URI for %s\n",
program, base_uri_string);
return(1);
}
}
rdf_parser=raptor_new_parser(syntax_name);
if(!rdf_parser) {
fprintf(stderr, "%s: Failed to create raptor parser type %s\n", program,
syntax_name);
return(1);
}
raptor_set_error_handler(rdf_parser, rdf_parser, rdfdump_error_handler);
raptor_set_warning_handler(rdf_parser, rdf_parser, rdfdump_warning_handler);
raptor_set_parser_strict(rdf_parser, strict_mode);
if(scanning)
raptor_set_feature(rdf_parser, RAPTOR_FEATURE_SCANNING, 1);
if(!quiet) {
if (filename) {
if(base_uri_string)
fprintf(stdout, "%s: Parsing file %s with base URI %s\n", program,
filename, base_uri_string);
else
fprintf(stdout, "%s: Parsing file %s\n", program, filename);
} else {
if(base_uri_string)
fprintf(stdout, "%s: Parsing URI %s with base URI %s\n", program,
uri_string, base_uri_string);
else
fprintf(stdout, "%s: Parsing URI %s\n", program, uri_string);
}
}
raptor_set_statement_handler(rdf_parser, NULL, print_statements);
/* PARSE the URI as RDF/XML */
rc=0;
if(!uri || filename) {
if(raptor_parse_file(rdf_parser, uri, base_uri)) {
fprintf(stderr, "%s: Failed to parse file %s %s content\n", program,
filename, syntax_name);
rc=1;
}
} else {
if(raptor_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(!quiet)
fprintf(stdout, "%s: Parsing returned %d statements\n", program,
statement_count);
raptor_free_uri(base_uri);
if(uri)
raptor_free_uri(uri);
if(free_uri_string)
free(uri_string);
raptor_finish();
if(error_count && !ignore_errors)
return 1;
if(warning_count && !ignore_warnings)
return 2;
return(rc);
}
