void
raptor_rss_common_terminate(raptor_world* world) {
int i;
if(--world->rss_common_initialised)
return;
if(world->rss_types_info_uris) {
for(i = 0; i< RAPTOR_RSS_COMMON_SIZE; i++) {
if(world->rss_types_info_uris[i])
raptor_free_uri(world->rss_types_info_uris[i]);
}
RAPTOR_FREE(raptor_uri* array, world->rss_types_info_uris);
world->rss_types_info_uris = NULL;
}
if(world->rss_fields_info_uris) {
for(i = 0; i< RAPTOR_RSS_FIELDS_SIZE; i++) {
if(world->rss_fields_info_uris[i])
raptor_free_uri(world->rss_fields_info_uris[i]);
}
RAPTOR_FREE(raptor_uri* array, world->rss_fields_info_uris);
world->rss_fields_info_uris = NULL;
}
if(world->rss_namespaces_info_uris) {
for(i = 0; i < RAPTOR_RSS_NAMESPACES_SIZE;i++) {
if(world->rss_namespaces_info_uris[i])
raptor_free_uri(world->rss_namespaces_info_uris[i]);
}
RAPTOR_FREE(raptor_uri* array, world->rss_namespaces_info_uris);
world->rss_namespaces_info_uris = NULL;
}
}
/*****
** Lee el archivo que contiene las tripletas RDF
** y hace el llamado a la funcion save_triple() para guardarlos
*****/
void rdf_database_read_file(rdf_database db, const char *file)
{
raptor_world *world = NULL;
unsigned char *uri_string;
raptor_uri *uri, *base_uri;
// parser
world = raptor_new_world();
rdf_parser = raptor_new_parser(world, "rdfxml");
// seteo funcion handler para cada nodo
raptor_parser_set_statement_handler(rdf_parser, (void*)db, save_triple);
uri_string = raptor_uri_filename_to_uri_string(file);
uri = raptor_new_uri(world, uri_string);
base_uri = raptor_uri_copy(uri);
// empieza parseo y guardado en memoria
raptor_parser_parse_file(rdf_parser, uri, base_uri);
// liberar ram
raptor_free_parser(rdf_parser);
raptor_free_uri(base_uri);
raptor_free_uri(uri);
raptor_free_memory(uri_string);
raptor_free_world(world);
}
int
main(int argc, char *argv[])
{
#ifdef HAVE_RAPTOR
raptor_world *world = NULL;
raptor_parser* rdf_parser = NULL;
unsigned char *uri_string;
raptor_uri *uri, *base_uri;
world = raptor_new_world();
rdf_parser = raptor_new_parser(world, "ntriples");
raptor_parser_set_statement_handler(rdf_parser, NULL, print_triple);
uri_string = raptor_uri_filename_to_uri_string(argv[1]);
uri = raptor_new_uri(world, uri_string);
base_uri = raptor_uri_copy(uri);
raptor_parser_parse_file(rdf_parser, uri, base_uri);
raptor_free_parser(rdf_parser);
raptor_free_uri(base_uri);
raptor_free_uri(uri);
raptor_free_memory(uri_string);
raptor_free_world(world);
#endif
return EXIT_SUCCESS;
}
DllExport int call_conv load_nquad_file(CTXTdecl)
{
char *filename = p2c_string(reg_term(CTXTdecl 1));
unsigned char *uri_string;
raptor_uri *uri, *base_uri;
world = raptor_new_world();
rdf_parser = raptor_new_parser(world, "nquads");
raptor_parser_set_statement_handler(rdf_parser, NULL, handle_term);
uri_string = raptor_uri_filename_to_uri_string(filename);
uri = raptor_new_uri(world, uri_string);
base_uri = raptor_uri_copy(uri);
raptor_parser_parse_file(rdf_parser, uri, base_uri);
raptor_free_parser(rdf_parser);
raptor_free_uri(base_uri);
raptor_free_uri(uri);
raptor_free_memory(uri_string);
raptor_free_world(world);
return 1;
}
static int
assert_uri_to_relative(const char *base, const char *uri, const char *relative)
{
unsigned char *output;
int result;
raptor_uri* base_uri=NULL;
raptor_uri* reference_uri=raptor_new_uri((const unsigned char*)uri);
size_t length=0;
if(base)
base_uri=raptor_new_uri((const unsigned char*)base);
output=raptor_uri_to_relative_counted_uri_string(base_uri, reference_uri,
&length);
result=strcmp(relative, (const char*)output);
if (result) {
fprintf(stderr,
"%s: raptor_uri_string_to_relative_uri_string FAILED: base='%s', uri='%s', expected='%s', got='%s'\n",
program, base, uri, relative, output);
RAPTOR_FREE(cstring, output);
return 1;
}
RAPTOR_FREE(cstring, output);
raptor_free_uri(base_uri);
raptor_free_uri(reference_uri);
return 0;
}
/**
* raptor_free_www:
* @www: WWW object.
*
* Destructor - destroy a #raptor_www object.
**/
void
raptor_free_www(raptor_www* www)
{
/* free context */
if(www->type) {
if(www->free_type)
RAPTOR_FREE(cstring, www->type);
www->type = NULL;
}
if(www->user_agent) {
RAPTOR_FREE(cstring, www->user_agent);
www->user_agent = NULL;
}
if(www->cache_control) {
RAPTOR_FREE(cstring, www->cache_control);
www->cache_control = NULL;
}
if(www->proxy) {
RAPTOR_FREE(cstring, www->proxy);
www->proxy = NULL;
}
if(www->http_accept) {
RAPTOR_FREE(cstring, www->http_accept);
www->http_accept = NULL;
}
#ifdef RAPTOR_WWW_LIBCURL
raptor_www_curl_free(www);
#endif
#ifdef RAPTOR_WWW_LIBXML
raptor_www_libxml_free(www);
#endif
#ifdef RAPTOR_WWW_LIBFETCH
raptor_www_libfetch_free(www);
#endif
if(www->uri)
raptor_free_uri(www->uri);
if(www->final_uri)
raptor_free_uri(www->final_uri);
RAPTOR_FREE(www, www);
}
/**
* raptor_free_term:
* @term: #raptor_term object
*
* Destructor - destroy a raptor_term object.
*
**/
void
raptor_free_term(raptor_term *term)
{
if(!term)
return;
if(--term->usage)
return;
switch(term->type) {
case RAPTOR_TERM_TYPE_URI:
if(term->value.uri) {
raptor_free_uri(term->value.uri);
term->value.uri = NULL;
}
break;
case RAPTOR_TERM_TYPE_BLANK:
if(term->value.blank.string) {
RAPTOR_FREE(cstring, (void*)term->value.blank.string);
term->value.blank.string = NULL;
}
break;
case RAPTOR_TERM_TYPE_LITERAL:
if(term->value.literal.string) {
RAPTOR_FREE(cstring, (void*)term->value.literal.string);
term->value.literal.string = NULL;
}
if(term->value.literal.datatype) {
raptor_free_uri(term->value.literal.datatype);
term->value.literal.datatype = NULL;
}
if(term->value.literal.language) {
RAPTOR_FREE(cstring, (void*)term->value.literal.language);
term->value.literal.language = NULL;
}
break;
case RAPTOR_TERM_TYPE_UNKNOWN:
default:
break;
}
RAPTOR_FREE(term, (void*)term);
}
/**
* raptor_free_sax2:
* @sax2: SAX2 object
*
* Destructor - destroy a SAX2 object
*/
void
raptor_free_sax2(raptor_sax2 *sax2)
{
raptor_xml_element *xml_element;
if(!sax2)
return;
#ifdef RAPTOR_XML_LIBXML
if(sax2->xc) {
raptor_libxml_free(sax2->xc);
sax2->xc = NULL;
}
#endif
while( (xml_element = raptor_xml_element_pop(sax2)) )
raptor_free_xml_element(xml_element);
raptor_namespaces_clear(&sax2->namespaces);
if(sax2->base_uri)
raptor_free_uri(sax2->base_uri);
raptor_object_options_clear(&sax2->options);
RAPTOR_FREE(raptor_sax2, sax2);
}
int main(int argc, char *argv[]) {
fsp_link *link;
fs_query_state *qs;
fs_query *qr;
raptor_uri *bu;
int i;
#ifdef LINUX
mtrace();
#endif
link = fsp_open_link("ukgov_finances_cra", NULL, FS_OPEN_HINT_RW);
raptor_init();
fs_hash_init(fsp_hash_type(link));
bu = raptor_new_uri((unsigned char *)"local:");
fsp_no_op(link, 0);
qs = fs_query_init(link);
for (i=0;i<atoi(argv[1]);i++) {
//printf("--------- %d ----------\n", i);
qr = fs_query_execute(qs, link, bu, QUERY, 0, 3, 0);
fs_query_free(qr);
fs_query_cache_flush(qs, 0);
}
fs_query_fini(qs);
raptor_free_uri(bu);
raptor_finish();
fsp_close_link(link);
#ifdef LINUX
muntrace();
#endif
}
/**
* raptor_serializer_start_to_string:
* @rdf_serializer: the #raptor_serializer
* @uri: base URI or NULL if no base URI is required
* @string_p: pointer to location to hold string
* @length_p: pointer to location to hold length of string (or NULL)
*
* Start serializing to a string.
*
* Return value: non-0 on failure.
**/
int
raptor_serializer_start_to_string(raptor_serializer *rdf_serializer,
raptor_uri *uri,
void **string_p, size_t *length_p)
{
if(rdf_serializer->base_uri)
raptor_free_uri(rdf_serializer->base_uri);
if(uri)
rdf_serializer->base_uri = raptor_uri_copy(uri);
else
rdf_serializer->base_uri = NULL;
rdf_serializer->locator.uri = rdf_serializer->base_uri;
rdf_serializer->locator.line = rdf_serializer->locator.column = 0;
rdf_serializer->iostream = raptor_new_iostream_to_string(rdf_serializer->world,
string_p, length_p,
NULL);
if(!rdf_serializer->iostream)
return 1;
rdf_serializer->free_iostream_on_end = 1;
if(rdf_serializer->factory->serialize_start)
return rdf_serializer->factory->serialize_start(rdf_serializer);
return 0;
}
/**
* raptor_free_xml_element:
* @element: XML Element
*
* Destructor - destroy a raptor_xml_element object.
**/
void
raptor_free_xml_element(raptor_xml_element *element)
{
unsigned int i;
if(!element)
return;
for(i = 0; i < element->attribute_count; i++)
if(element->attributes[i])
raptor_free_qname(element->attributes[i]);
if(element->attributes)
RAPTOR_FREE(raptor_qname_array, element->attributes);
if(element->content_cdata_sb)
raptor_free_stringbuffer(element->content_cdata_sb);
if(element->base_uri)
raptor_free_uri(element->base_uri);
if(element->xml_language)
RAPTOR_FREE(char*, element->xml_language);
raptor_free_qname(element->name);
if(element->declared_nspaces)
raptor_free_sequence(element->declared_nspaces);
RAPTOR_FREE(raptor_element, element);
}
/**
* raptor_serializer_start_to_filename:
* @rdf_serializer: the #raptor_serializer
* @filename: filename to serialize to
*
* Start serializing to a filename.
*
* Return value: non-0 on failure.
**/
int
raptor_serializer_start_to_filename(raptor_serializer *rdf_serializer,
const char *filename)
{
unsigned char *uri_string = raptor_uri_filename_to_uri_string(filename);
if(!uri_string)
return 1;
if(rdf_serializer->base_uri)
raptor_free_uri(rdf_serializer->base_uri);
rdf_serializer->base_uri = raptor_new_uri(rdf_serializer->world, uri_string);
rdf_serializer->locator.uri = rdf_serializer->base_uri;
rdf_serializer->locator.line = rdf_serializer->locator.column = 0;
RAPTOR_FREE(char*, uri_string);
rdf_serializer->iostream = raptor_new_iostream_to_filename(rdf_serializer->world,
filename);
if(!rdf_serializer->iostream)
return 1;
rdf_serializer->free_iostream_on_end = 1;
if(rdf_serializer->factory->serialize_start)
return rdf_serializer->factory->serialize_start(rdf_serializer);
return 0;
}
void
raptor_rss_model_clear(raptor_rss_model* rss_model)
{
int i;
raptor_rss_item* item;
for(i = 0; i< RAPTOR_RSS_COMMON_SIZE; i++) {
item = rss_model->common[i];
while(item) {
raptor_rss_item *next = item->next;
raptor_free_rss_item(item);
item = next;
}
}
item = rss_model->items;
while(item) {
raptor_rss_item *next = item->next;
raptor_free_rss_item(item);
item = next;
}
rss_model->last = rss_model->items = NULL;
for(i = 0; i< RAPTOR_RSS_N_CONCEPTS; i++) {
raptor_uri* concept_uri = rss_model->concepts[i];
if(concept_uri) {
raptor_free_uri(concept_uri);
rss_model->concepts[i] = NULL;
}
}
}
/**
* raptor_serializer_start_to_iostream:
* @rdf_serializer: the #raptor_serializer
* @uri: base URI or NULL if no base URI is required
* @iostream: #raptor_iostream to write serialization to
*
* Start serialization to an iostream with given base URI
*
* The passed in @iostream does not become owned by the serializer
* and can be used by the caller after serializing is done. It
* must be destroyed by the caller.
*
* Return value: non-0 on failure.
**/
int
raptor_serializer_start_to_iostream(raptor_serializer *rdf_serializer,
raptor_uri *uri, raptor_iostream *iostream)
{
if(rdf_serializer->base_uri)
raptor_free_uri(rdf_serializer->base_uri);
if(!iostream)
return 1;
if(uri)
uri = raptor_uri_copy(uri);
rdf_serializer->base_uri = uri;
rdf_serializer->locator.uri = uri;
rdf_serializer->locator.line = rdf_serializer->locator.column = 0;
rdf_serializer->iostream = iostream;
rdf_serializer->free_iostream_on_end = 0;
if(rdf_serializer->factory->serialize_start)
return rdf_serializer->factory->serialize_start(rdf_serializer);
return 0;
}
static void
ser_emit_triple(void* user_data,
const char* subject, int subject_type,
const char* predicate_nspace, const char* predicate_name,
const char *object, int object_type,
const char *datatype_uri)
{
raptor_serializer* serializer = (raptor_serializer*)user_data;
raptor_statement s; /* static */
raptor_uri* predicate_ns_uri;
raptor_uri* predicate_uri;
raptor_statement_init(&s, rworld);
if(subject_type == FLICKCURL_TERM_TYPE_RESOURCE)
s.subject = raptor_new_term_from_uri_string(rworld, (const unsigned char*)subject);
else /* blank node */
s.subject = raptor_new_term_from_blank(rworld, (const unsigned char*)subject);
predicate_ns_uri = raptor_new_uri(rworld, (const unsigned char*)predicate_nspace);
predicate_uri = raptor_new_uri_from_uri_local_name(rworld, predicate_ns_uri,
(const unsigned char*)predicate_name);
s.predicate = raptor_new_term_from_uri(rworld, predicate_uri);
raptor_free_uri(predicate_uri);
raptor_free_uri(predicate_ns_uri);
if(object_type == FLICKCURL_TERM_TYPE_RESOURCE)
s.object = (void*)raptor_new_term_from_uri_string(rworld, (const unsigned char*)object);
else if(object_type == FLICKCURL_TERM_TYPE_BLANK)
s.object = raptor_new_term_from_blank(rworld, (const unsigned char*)subject);
else {
/* literal */
raptor_uri* raptor_datatype_uri = NULL;
if(datatype_uri)
raptor_datatype_uri = raptor_new_uri(rworld, (const unsigned char*)datatype_uri);
s.object = raptor_new_term_from_literal(rworld, (const unsigned char*)object, raptor_datatype_uri, NULL /* language */);
raptor_free_uri(raptor_datatype_uri);
}
raptor_serializer_serialize_statement(serializer, &s);
raptor_statement_clear(&s);
}
/**
* librdf_free_uri:
* @uri: #librdf_uri object
*
* Destructor - destroy a #librdf_uri object.
*
**/
void
librdf_free_uri(librdf_uri* uri)
{
if(!uri)
return;
raptor_free_uri(uri);
}
int main (int argc, char *argv[])
{
const char *program = raptor_basename(argv[0]);
raptor_world *world;
const char *uri_string;
raptor_www *www;
const char *user_agent = "raptor_www_test/0.1";
raptor_uri *uri;
void *string = NULL;
size_t string_length = 0;
if(argc > 1)
uri_string = argv[1];
else
uri_string = "http://librdf.org/";
world = raptor_new_world();
if(!world || raptor_world_open(world))
exit(1);
uri = raptor_new_uri(world, (const unsigned char*)uri_string);
if(!uri) {
fprintf(stderr, "%s: Failed to create Raptor URI for %s\n",
program, uri_string);
exit(1);
}
www = raptor_new_www(world);
raptor_www_set_content_type_handler(www, write_content_type, (void*)stderr);
raptor_www_set_user_agent(www, user_agent);
/* start retrieval (always a GET) */
if(raptor_www_fetch_to_string(www, uri,
&string, &string_length, malloc)) {
fprintf(stderr, "%s: WWW fetch failed\n", program);
} else {
#if defined(RAPTOR_DEBUG) && RAPTOR_DEBUG > 1
fprintf(stderr, "%s: HTTP response status %d\n",
program, www->status_code);
fprintf(stderr, "%s: Returned %d bytes of content\n",
program, (int)string_length);
#endif
}
if(string)
free(string);
raptor_free_www(www);
raptor_free_uri(uri);
raptor_free_world(world);
return 0;
}
static void
rasqal_finish_datatypes(void) {
int i;
for(i = 0; i< RASQAL_XSD_DATATYPES_SIZE; i++)
if(rasqal_xsd_datatypes[i].uri)
raptor_free_uri(rasqal_xsd_datatypes[i].uri);
for(i = 0; i< RASQAL_XSD_DATATYPE_FNS_SIZE; i++)
if(rasqal_xsd_datatype_fns[i].uri)
raptor_free_uri(rasqal_xsd_datatype_fns[i].uri);
if(raptor_xpfo_base_uri)
raptor_free_uri(raptor_xpfo_base_uri);
if(rasqal_sparql_op_namespace_uri)
raptor_free_uri(rasqal_sparql_op_namespace_uri);
}
/**
* raptor_free_base_id_set:
* @set: #raptor_base_id_set
*
* INTERNAL - Destructor - Free a Base ID Set.
*
**/
static void
raptor_free_base_id_set(raptor_base_id_set *base)
{
if(base->tree)
raptor_free_avltree(base->tree);
if(base->uri)
raptor_free_uri(base->uri);
RAPTOR_FREE(raptor_base_id_set, base);
}
fs_metadata *fs_metadata_open(const char *kb)
{
fs_metadata *m = calloc(1, sizeof(fs_metadata));
gchar *fs_md_file_uri_format;
fs_md_file_uri_format = g_strconcat("file://",
fs_get_md_file_format(),
NULL);
m->size = 16;
m->length = 0;
m->entries = calloc(m->size, sizeof(struct m_entry));
m->uri = g_strdup_printf(fs_md_file_uri_format, kb);
g_free(fs_md_file_uri_format);
int fd;
if ((fd = open(m->uri + 7, FS_O_NOATIME | O_CREAT, FS_FILE_MODE)) == -1) {
fs_error(LOG_CRIT, "failed to touch metadata file %s: %s",
m->uri, strerror(errno));
free(m);
return NULL;
}
close(fd);
m->rw = raptor_new_world();
if (!m->rw) {
fs_error(LOG_CRIT, "failed to initialise raptor");
free(m);
return NULL;
}
raptor_parser *rdf_parser = raptor_new_parser(m->rw, "turtle");
raptor_parser_set_statement_handler(rdf_parser, m, parse_stmt);
char *uri = strdup(m->uri);
raptor_uri *ruri = raptor_new_uri(m->rw, (unsigned char *) uri);
raptor_uri *muri = raptor_new_uri(m->rw, (unsigned char *) uri);
free(uri);
if (raptor_parser_parse_uri(rdf_parser, ruri, muri)) {
fs_error(LOG_ERR, "failed to parse metadata file “%s”", m->uri);
return NULL;
}
raptor_free_parser(rdf_parser);
raptor_free_uri(ruri);
raptor_free_uri(muri);
return m;
}
/*
* rasqal_free_update_operation:
* @update: update operation
*
* INTERNAL - Destructor - Free update operation
*
*/
void
rasqal_free_update_operation(rasqal_update_operation *update)
{
if(!update)
return;
if(update->graph_uri)
raptor_free_uri(update->graph_uri);
if(update->document_uri)
raptor_free_uri(update->document_uri);
if(update->insert_templates)
raptor_free_sequence(update->insert_templates);
if(update->delete_templates)
raptor_free_sequence(update->delete_templates);
if(update->where)
rasqal_free_graph_pattern(update->where);
RASQAL_FREE(update_operation, update);
}
/**
* librdf_free_uri:
* @uri: #librdf_uri object
*
* Destructor - destroy a #librdf_uri object.
*
**/
void
librdf_free_uri(librdf_uri* uri)
{
#ifdef LIBRDF_USE_RAPTOR_URI
if(!uri)
return;
raptor_free_uri(uri);
#else
librdf_hash_datum key; /* on stack */
#ifdef WITH_THREADS
librdf_world *world;
#endif
if(!uri)
return;
#ifdef WITH_THREADS
world = uri->world;
pthread_mutex_lock(world->mutex);
#endif
uri->usage--;
#if defined(LIBRDF_DEBUG) && LIBRDF_DEBUG > 1
LIBRDF_DEBUG3("URI %s usage count now %d\n", uri->string, uri->usage);
#endif
/* decrement usage, don't free if not 0 yet*/
if(uri->usage) {
#ifdef WITH_THREADS
pthread_mutex_unlock(world->mutex);
#endif
return;
}
#if defined(LIBRDF_DEBUG) && LIBRDF_DEBUG > 1
LIBRDF_DEBUG3("Deleting URI %s from hash, max usage was %d\n", uri->string, uri->max_usage);
#endif
key.data=uri->string;
key.size=uri->string_length;
/* Hash deletion fails only if the key is not found.
This is not a fatal error so do not check for return value. */
librdf_hash_delete_all(uri->world->uris_hash, &key);
if(uri->string)
LIBRDF_FREE(cstring, uri->string);
LIBRDF_FREE(librdf_uri, uri);
#ifdef WITH_THREADS
pthread_mutex_unlock(world->mutex);
#endif
#endif /* !LIBRDF_USE_RAPTOR_URI */
}
void
rasqal_xsd_finish(rasqal_world* world)
{
if(world->xsd_datatype_uris) {
int i;
for(i = RASQAL_LITERAL_FIRST_XSD; i < SPARQL_XSD_NAMES_COUNT; i++) {
if(world->xsd_datatype_uris[i])
raptor_free_uri(world->xsd_datatype_uris[i]);
}
RASQAL_FREE(table, world->xsd_datatype_uris);
world->xsd_datatype_uris = NULL;
}
if(world->xsd_namespace_uri) {
raptor_free_uri(world->xsd_namespace_uri);
world->xsd_namespace_uri = NULL;
}
}
void
rasqal_uri_finish(rasqal_world* world)
{
if(world->rdf_first_uri) {
raptor_free_uri(world->rdf_first_uri);
world->rdf_first_uri=NULL;
}
if(world->rdf_rest_uri) {
raptor_free_uri(world->rdf_rest_uri);
world->rdf_rest_uri=NULL;
}
if(world->rdf_nil_uri) {
raptor_free_uri(world->rdf_nil_uri);
world->rdf_nil_uri=NULL;
}
if(world->rdf_namespace_uri) {
raptor_free_uri(world->rdf_namespace_uri);
world->rdf_namespace_uri=NULL;
}
}
/**
* raptor_free_turtle_writer:
* @turtle_writer: Turtle writer object
*
* Destructor - Free Turtle Writer
*
**/
void
raptor_free_turtle_writer(raptor_turtle_writer* turtle_writer)
{
if(!turtle_writer)
return;
if(turtle_writer->nstack && turtle_writer->my_nstack)
raptor_free_namespaces(turtle_writer->nstack);
if(turtle_writer->xsd_boolean_uri)
raptor_free_uri(turtle_writer->xsd_boolean_uri);
if(turtle_writer->xsd_decimal_uri)
raptor_free_uri(turtle_writer->xsd_decimal_uri);
if(turtle_writer->xsd_double_uri)
raptor_free_uri(turtle_writer->xsd_double_uri);
if(turtle_writer->xsd_integer_uri)
raptor_free_uri(turtle_writer->xsd_integer_uri);
RAPTOR_FREE(raptor_turtle_writer, turtle_writer);
}
void
raptor_rss_field_free(raptor_rss_field* field)
{
if(field->value)
RAPTOR_FREE(cstring, field->value);
if(field->uri)
raptor_free_uri(field->uri);
if(field->next)
raptor_rss_field_free(field->next);
RAPTOR_FREE(raptor_rss_field, field);
}
void
raptor_free_abbrev_node(raptor_abbrev_node* node)
{
if(!node)
return;
if(--node->ref_count)
return;
switch (node->type) {
case RAPTOR_IDENTIFIER_TYPE_RESOURCE:
case RAPTOR_IDENTIFIER_TYPE_PREDICATE:
raptor_free_uri(node->value.resource.uri);
break;
case RAPTOR_IDENTIFIER_TYPE_ANONYMOUS:
RAPTOR_FREE(blank, node->value.blank.string);
break;
case RAPTOR_IDENTIFIER_TYPE_LITERAL:
case RAPTOR_IDENTIFIER_TYPE_XML_LITERAL:
RAPTOR_FREE(literal, node->value.literal.string);
if(node->value.literal.datatype)
raptor_free_uri(node->value.literal.datatype);
if(node->value.literal.language)
RAPTOR_FREE(language, node->value.literal.language);
break;
case RAPTOR_IDENTIFIER_TYPE_ORDINAL:
case RAPTOR_IDENTIFIER_TYPE_UNKNOWN:
default:
/* Nothing to do */
break;
}
RAPTOR_FREE(raptor_abbrev_node, node);
}
static void
raptor_rss_parse_terminate(raptor_parser *rdf_parser) {
raptor_rss_parser_context *rss_parser=(raptor_rss_parser_context*)rdf_parser->context;
int i;
if(rss_parser->reader)
xmlFreeTextReader(rss_parser->reader);
if(rss_parser->input)
xmlFreeParserInputBuffer(rss_parser->input);
raptor_rss_items_free(rss_parser);
for(i=0; i< RAPTOR_RSS_COMMON_SIZE; i++)
raptor_item_free(&rss_parser->common[i]);
for(i=0; i<RSS_NAMESPACES_SIZE;i++) {
if(rss_parser->namespace_uris[i])
raptor_free_uri(rss_parser->namespace_uris[i]);
}
for(i=0; i< RAPTOR_RSS_N_CONCEPTS; i++) {
raptor_uri* concept_uri=rss_parser->concepts[i];
if(concept_uri) {
raptor_free_uri(concept_uri);
rss_parser->concepts[i]=NULL;
}
}
for(i=0; i< RAPTOR_RSS_COMMON_SIZE; i++) {
if(raptor_rss_types_info[i].uri)
raptor_free_uri(raptor_rss_types_info[i].uri);
}
for(i=0; i< RAPTOR_RSS_FIELDS_SIZE; i++) {
if(raptor_rss_fields_info[i].uri)
raptor_free_uri(raptor_rss_fields_info[i].uri);
}
}
static void
ser_emit_namespace(void* user_data,
const char *prefix, size_t prefix_len,
const char* uri, size_t uri_len)
{
raptor_serializer* serializer = (raptor_serializer*)user_data;
raptor_uri *ns_uri = NULL;
ns_uri = raptor_new_uri(rworld, (const unsigned char*)uri);
raptor_serializer_set_namespace(serializer, ns_uri,
(const unsigned char*)prefix);
raptor_free_uri(ns_uri);
}
int
main (int argc, char *argv[])
{
raptor_parser* rdf_parser;
raptor_uri* uri;
my_data* me;
const char *program;
int rc;
program=argv[0];
if(argc != 2) {
fprintf(stderr, "%s: USAGE [RDF-XML content URI]\n", program);
exit(1);
}
raptor_init();
me=(my_data*)malloc(sizeof(my_data));
if(!me) {
fprintf(stderr, "%s: Out of memory\n", program);
exit(1);
}
me->stream=stderr;
me->count=0;
me->max=5;
uri=raptor_new_uri((const unsigned char*)argv[1]);
rdf_parser=raptor_new_parser("rdfxml");
me->parser=rdf_parser;
raptor_set_statement_handler(rdf_parser, me, handle_statements);
me->stopped=0;
rc=raptor_parse_uri(rdf_parser, uri, NULL);
fprintf(stderr, "%s: Parser returned status %d, stopped? %s\n", program, rc,
(me->stopped ? "yes" : "no"));
free(me);
raptor_free_parser(rdf_parser);
raptor_free_uri(uri);
raptor_finish();
return 0;
}