1 /* -*- Mode: c; c-basic-offset: 2 -*-
2 *
3 * raptor_serialize.c - Serializers
4 *
5 * Copyright (C) 2004-2008, David Beckett http://www.dajobe.org/
6 * Copyright (C) 2004-2005, University of Bristol, UK http://www.bristol.ac.uk/
7 *
8 * This package is Free Software and part of Redland http://librdf.org/
9 *
10 * It is licensed under the following three licenses as alternatives:
11 * 1. GNU Lesser General Public License (LGPL) V2.1 or any newer version
12 * 2. GNU General Public License (GPL) V2 or any newer version
13 * 3. Apache License, V2.0 or any newer version
14 *
15 * You may not use this file except in compliance with at least one of
16 * the above three licenses.
17 *
18 * See LICENSE.html or LICENSE.txt at the top of this package for the
19 * complete terms and further detail along with the license texts for
20 * the licenses in COPYING.LIB, COPYING and LICENSE-2.0.txt respectively.
21 *
22 */
23
24
25 #ifdef HAVE_CONFIG_H
26 #include <raptor_config.h>
27 #endif
28
29 #ifdef WIN32
30 #include <win32_raptor_config.h>
31 #endif
32
33
34 #include <stdio.h>
35 #include <string.h>
36 #include <ctype.h>
37 #include <stdarg.h>
38 #ifdef HAVE_ERRNO_H
39 #include <errno.h>
40 #endif
41 #ifdef HAVE_STDLIB_H
42 #include <stdlib.h>
43 #endif
44
45 /* Raptor includes */
46 #include "raptor.h"
47 #include "raptor_internal.h"
48
49
50 /* prototypes for helper functions */
51 static raptor_serializer_factory* raptor_get_serializer_factory(raptor_world* world, const char *name);
52
53
54 /* helper methods */
55
56 static void
raptor_free_serializer_factory(raptor_serializer_factory * factory)57 raptor_free_serializer_factory(raptor_serializer_factory* factory)
58 {
59 RAPTOR_ASSERT_OBJECT_POINTER_RETURN(factory, raptor_serializer_factory);
60
61 if(factory->finish_factory)
62 factory->finish_factory(factory);
63
64 if(factory->name)
65 RAPTOR_FREE(raptor_serializer_factory, (void*)factory->name);
66 if(factory->label)
67 RAPTOR_FREE(raptor_serializer_factory, (void*)factory->label);
68 if(factory->alias)
69 RAPTOR_FREE(raptor_serializer_factory, (void*)factory->alias);
70 if(factory->mime_type)
71 RAPTOR_FREE(cstring, factory->mime_type);
72 if(factory->uri_string)
73 RAPTOR_FREE(raptor_serializer_factory, (void*)factory->uri_string);
74
75 RAPTOR_FREE(raptor_serializer_factory, factory);
76 }
77
78
79 /* class methods */
80
81 int
raptor_serializers_init(raptor_world * world)82 raptor_serializers_init(raptor_world* world)
83 {
84 int rc=0;
85
86 world->serializers=raptor_new_sequence((raptor_sequence_free_handler *)raptor_free_serializer_factory, NULL);
87 if(!world->serializers)
88 return 1;
89
90 /* raptor_init_serializer_simple(); */
91
92 #ifdef RAPTOR_SERIALIZER_NTRIPLES
93 rc+= raptor_init_serializer_ntriples(world) != 0;
94 #endif
95
96 #ifdef RAPTOR_SERIALIZER_TURTLE
97 rc+= raptor_init_serializer_turtle(world) != 0;
98 #endif
99
100 #ifdef RAPTOR_SERIALIZER_RDFXML_ABBREV
101 rc+= raptor_init_serializer_rdfxmla(world) != 0;
102 #endif
103
104 #ifdef RAPTOR_SERIALIZER_RDFXML
105 rc+= raptor_init_serializer_rdfxml(world) != 0;
106 #endif
107
108 #ifdef RAPTOR_SERIALIZER_RSS_1_0
109 rc+= raptor_init_serializer_rss10(world) != 0;
110 #endif
111
112 #ifdef RAPTOR_SERIALIZER_ATOM
113 rc+= raptor_init_serializer_atom(world) != 0;
114 #endif
115
116 #ifdef RAPTOR_SERIALIZER_DOT
117 rc+= raptor_init_serializer_dot(world) != 0;
118 #endif
119
120 #ifdef RAPTOR_SERIALIZER_JSON
121 rc+= raptor_init_serializer_json(world) != 0;
122 #endif
123
124 return rc;
125 }
126
127
128 /*
129 * raptor_serializers_finish - delete all the registered serializers
130 */
131 void
raptor_serializers_finish(raptor_world * world)132 raptor_serializers_finish(raptor_world* world)
133 {
134 if(world->serializers) {
135 raptor_free_sequence(world->serializers);
136 world->serializers=NULL;
137 }
138 }
139
140
141 /*
142 * raptor_serializer_register_factory - Register a syntax that can be generated by a serializer factory
143 * @world: raptor_world object
144 * @name: the short syntax name
145 * @label: readable label for syntax
146 * @mime_type: MIME type of the syntax generated by the serializer (or NULL)
147 * @uri_string: URI string of the syntax (or NULL)
148 * @factory: pointer to function to call to register the factory
149 *
150 * INTERNAL
151 *
152 * Return value: non-0 on failure
153 **/
154 RAPTOR_EXTERN_C
155 int
raptor_serializer_register_factory(raptor_world * world,const char * name,const char * label,const char * mime_type,const char * alias,const unsigned char * uri_string,int (* factory)(raptor_serializer_factory *))156 raptor_serializer_register_factory(raptor_world* world,
157 const char *name, const char *label,
158 const char *mime_type,
159 const char *alias,
160 const unsigned char *uri_string,
161 int (*factory) (raptor_serializer_factory*))
162 {
163 raptor_serializer_factory *serializer;
164 char *name_copy, *label_copy, *mime_type_copy, *alias_copy;
165 unsigned char *uri_string_copy;
166 int i;
167
168 #if defined(RAPTOR_DEBUG) && RAPTOR_DEBUG > 1
169 RAPTOR_DEBUG4("Received registration for syntax serializer %s '%s' with alias '%s'\n",
170 name, label, (alias ? alias : "none"));
171 RAPTOR_DEBUG3("MIME type %s, URI %s\n",
172 (mime_type ? mime_type : "none"),
173 (uri_string ? (const char *)uri_string : "none"));
174 #endif
175
176 for(i=0;
177 (serializer=(raptor_serializer_factory*)raptor_sequence_get_at(world->serializers, i));
178 i++) {
179 if(!strcmp(serializer->name, name)) {
180 RAPTOR_FATAL2("serializer %s already registered\n", name);
181 return 1;
182 }
183 }
184
185
186 serializer=(raptor_serializer_factory*)RAPTOR_CALLOC(raptor_serializer_factory, 1,
187 sizeof(raptor_serializer_factory));
188 if(!serializer)
189 return 1;
190
191 serializer->world=world;
192
193 name_copy=(char*)RAPTOR_CALLOC(cstring, strlen(name)+1, 1);
194 if(!name_copy)
195 goto tidy;
196 strcpy(name_copy, name);
197 serializer->name=name_copy;
198
199 label_copy=(char*)RAPTOR_CALLOC(cstring, strlen(label)+1, 1);
200 if(!label_copy)
201 goto tidy;
202 strcpy(label_copy, label);
203 serializer->label=label_copy;
204
205 if(mime_type) {
206 mime_type_copy=(char*)RAPTOR_CALLOC(cstring, strlen(mime_type)+1, 1);
207 if(!mime_type_copy)
208 goto tidy;
209 strcpy(mime_type_copy, mime_type);
210 serializer->mime_type=mime_type_copy;
211 }
212
213 if(uri_string) {
214 uri_string_copy=(unsigned char*)RAPTOR_CALLOC(cstring, strlen((const char*)uri_string)+1, 1);
215 if(!uri_string_copy)
216 goto tidy;
217 strcpy((char*)uri_string_copy, (const char*)uri_string);
218 serializer->uri_string=uri_string_copy;
219 }
220
221 if(alias) {
222 alias_copy=(char*)RAPTOR_CALLOC(cstring, strlen(alias)+1, 1);
223 if(!alias_copy)
224 goto tidy;
225 strcpy(alias_copy, alias);
226 serializer->alias=alias_copy;
227 }
228
229 if(raptor_sequence_push(world->serializers, serializer))
230 return 1; /* on error, serializer is already freed by the sequence */
231
232 /* Call the serializer registration function on the new object */
233 if (factory(serializer))
234 return 1; /* serializer is owned and freed by the serializers sequence */
235
236 #if defined(RAPTOR_DEBUG) && RAPTOR_DEBUG > 1
237 RAPTOR_DEBUG3("%s has context size %d\n", name, serializer->context_length);
238 #endif
239
240 return 0;
241
242 /* Clean up on failure */
243 tidy:
244 raptor_free_serializer_factory(serializer);
245 return 1;
246 }
247
248
249 /**
250 * raptor_get_serializer_factory:
251 * @world: raptor_world object
252 * @name: the factory name or NULL for the default factory
253 *
254 * Get a serializer factory by name.
255 *
256 * Return value: the factory object or NULL if there is no such factory
257 **/
258 static raptor_serializer_factory*
raptor_get_serializer_factory(raptor_world * world,const char * name)259 raptor_get_serializer_factory(raptor_world* world, const char *name)
260 {
261 raptor_serializer_factory *factory;
262
263 /* return 1st serializer if no particular one wanted - why? */
264 if(!name) {
265 factory=(raptor_serializer_factory *)raptor_sequence_get_at(world->serializers, 0);
266 if(!factory) {
267 RAPTOR_DEBUG1("No (default) serializers registered\n");
268 return NULL;
269 }
270 } else {
271 int i;
272
273 for(i=0;
274 (factory=(raptor_serializer_factory*)raptor_sequence_get_at(world->serializers, i));
275 i++) {
276 if(!strcmp(factory->name, name) ||
277 (factory->alias && !strcmp(factory->alias, name)))
278 break;
279
280 }
281
282 /* else FACTORY name not found */
283 if(!factory) {
284 RAPTOR_DEBUG2("No serializer with name %s found\n", name);
285 return NULL;
286 }
287 }
288
289 return factory;
290 }
291
292
293 #ifndef RAPTOR_DISABLE_V1
294 /**
295 * raptor_serializers_enumerate:
296 * @counter: index into the list of syntaxes
297 * @name: pointer to store the name of the syntax (or NULL)
298 * @label: pointer to store syntax readable label (or NULL)
299 * @mime_type: pointer to store syntax MIME Type (or NULL)
300 * @uri_string: pointer to store syntax URI string (or NULL)
301 *
302 * Get information on syntax serializers.
303 *
304 * raptor_init() MUST have been called before calling this function.
305 * Use raptor_serializers_enumerate_v2() if using raptor_world APIs.
306 *
307 * Return value: non 0 on failure of if counter is out of range
308 **/
309 int
raptor_serializers_enumerate(const unsigned int counter,const char ** name,const char ** label,const char ** mime_type,const unsigned char ** uri_string)310 raptor_serializers_enumerate(const unsigned int counter,
311 const char **name, const char **label,
312 const char **mime_type,
313 const unsigned char **uri_string)
314 {
315 return raptor_serializers_enumerate_v2(raptor_world_instance(),
316 counter,
317 name, label,
318 mime_type,
319 uri_string);
320 }
321 #endif
322
323
324 /**
325 * raptor_serializers_enumerate_v2:
326 * @world: raptor_world object
327 * @counter: index into the list of syntaxes
328 * @name: pointer to store the name of the syntax (or NULL)
329 * @label: pointer to store syntax readable label (or NULL)
330 * @mime_type: pointer to store syntax MIME Type (or NULL)
331 * @uri_string: pointer to store syntax URI string (or NULL)
332 *
333 * Get information on syntax serializers.
334 *
335 * Return value: non 0 on failure of if counter is out of range
336 **/
337 int
raptor_serializers_enumerate_v2(raptor_world * world,const unsigned int counter,const char ** name,const char ** label,const char ** mime_type,const unsigned char ** uri_string)338 raptor_serializers_enumerate_v2(raptor_world* world,
339 const unsigned int counter,
340 const char **name, const char **label,
341 const char **mime_type,
342 const unsigned char **uri_string)
343 {
344 raptor_serializer_factory *factory;
345
346 factory=(raptor_serializer_factory*)raptor_sequence_get_at(world->serializers,
347 counter);
348
349 if(!factory)
350 return 1;
351
352 if(name)
353 *name=factory->name;
354 if(label)
355 *label=factory->label;
356 if(mime_type)
357 *mime_type=factory->mime_type;
358 if(uri_string)
359 *uri_string=factory->uri_string;
360
361 return 0;
362 }
363
364
365 #ifndef RAPTOR_DISABLE_V1
366 /**
367 * raptor_serializer_syntax_name_check:
368 * @name: the syntax name
369 *
370 * Check name of a serializer.
371 *
372 * raptor_init() MUST have been called before calling this function.
373 * Use raptor_serializer_syntax_name_check_v2() if using raptor_world APIs.
374 *
375 * Return value: non 0 if name is a known syntax name
376 */
377 int
raptor_serializer_syntax_name_check(const char * name)378 raptor_serializer_syntax_name_check(const char *name)
379 {
380 return raptor_serializer_syntax_name_check_v2(raptor_world_instance(),
381 name);
382 }
383 #endif
384
385
386 /**
387 * raptor_serializer_syntax_name_check_v2:
388 * @world: raptor_world object
389 * @name: the syntax name
390 *
391 * Check name of a serializer.
392 *
393 * Return value: non 0 if name is a known syntax name
394 */
395 int
raptor_serializer_syntax_name_check_v2(raptor_world * world,const char * name)396 raptor_serializer_syntax_name_check_v2(raptor_world* world, const char *name)
397 {
398 return (raptor_get_serializer_factory(world, name) != NULL);
399 }
400
401
402 #ifndef RAPTOR_DISABLE_V1
403 /**
404 * raptor_new_serializer:
405 * @name: the serializer name
406 *
407 * Constructor - create a new raptor_serializer object.
408 *
409 * raptor_init() MUST have been called before calling this function.
410 * Use raptor_new_serializer_v2() if using raptor_world APIs.
411 *
412 * Return value: a new #raptor_serializer object or NULL on failure
413 */
414 raptor_serializer*
raptor_new_serializer(const char * name)415 raptor_new_serializer(const char *name)
416 {
417 return raptor_new_serializer_v2(raptor_world_instance(), name);
418 }
419 #endif
420
421
422 /**
423 * raptor_new_serializer_v2:
424 * @world: raptor_world object
425 * @name: the serializer name
426 *
427 * Constructor - create a new raptor_serializer object.
428 *
429 * Return value: a new #raptor_serializer object or NULL on failure
430 */
431 raptor_serializer*
raptor_new_serializer_v2(raptor_world * world,const char * name)432 raptor_new_serializer_v2(raptor_world* world, const char *name)
433 {
434 raptor_serializer_factory* factory;
435 raptor_serializer* rdf_serializer;
436
437 factory=raptor_get_serializer_factory(world, name);
438 if(!factory)
439 return NULL;
440
441 rdf_serializer=(raptor_serializer*)RAPTOR_CALLOC(raptor_serializer, 1,
442 sizeof(raptor_serializer));
443 if(!rdf_serializer)
444 return NULL;
445
446 rdf_serializer->world=world;
447
448 rdf_serializer->context=(char*)RAPTOR_CALLOC(raptor_serializer_context, 1,
449 factory->context_length);
450 if(!rdf_serializer->context) {
451 raptor_free_serializer(rdf_serializer);
452 return NULL;
453 }
454
455 rdf_serializer->factory=factory;
456
457 /* Default features */
458
459 /* Emit @base directive or equivalent */
460 rdf_serializer->feature_write_base_uri=1;
461
462 /* Emit relative URIs where possible */
463 rdf_serializer->feature_relative_uris=1;
464
465 rdf_serializer->feature_resource_border =
466 rdf_serializer->feature_literal_border =
467 rdf_serializer->feature_bnode_border =
468 rdf_serializer->feature_resource_fill =
469 rdf_serializer->feature_literal_fill =
470 rdf_serializer->feature_bnode_fill = NULL;
471
472 /* XML 1.0 output */
473 rdf_serializer->xml_version=10;
474
475 /* Write XML declaration */
476 rdf_serializer->feature_write_xml_declaration=1;
477
478 /* JSON callback function name */
479 rdf_serializer->feature_json_callback= NULL;
480
481 /* JSON extra data */
482 rdf_serializer->feature_json_extra_data= NULL;
483
484 /* RSS triples */
485 rdf_serializer->feature_rss_triples= NULL;
486
487 /* Atom entry URI */
488 rdf_serializer->feature_atom_entry_uri= NULL;
489
490 /* Prefix elements with a namespace */
491 rdf_serializer->feature_prefix_elements = 0;
492
493 if(factory->init(rdf_serializer, name)) {
494 raptor_free_serializer(rdf_serializer);
495 return NULL;
496 }
497
498 return rdf_serializer;
499 }
500
501
502 /**
503 * raptor_serialize_start_to_iostream:
504 * @rdf_serializer: the #raptor_serializer
505 * @uri: base URI or NULL if no base URI is required
506 * @iostream: #raptor_iostream to write serialization to
507 *
508 * Start serialization to an iostream with given base URI
509 *
510 * The passed in @iostream does not becomes owned by the serializer
511 * and can be used by the caller after serializing is done. It
512 * must be destroyed by the caller. Compare to
513 * raptor_serialize_start() which will be deprecated in future.
514 *
515 * Return value: non-0 on failure.
516 **/
517 int
raptor_serialize_start_to_iostream(raptor_serializer * rdf_serializer,raptor_uri * uri,raptor_iostream * iostream)518 raptor_serialize_start_to_iostream(raptor_serializer *rdf_serializer,
519 raptor_uri *uri, raptor_iostream *iostream)
520 {
521 if(rdf_serializer->base_uri)
522 raptor_free_uri_v2(rdf_serializer->world, rdf_serializer->base_uri);
523
524 if(!iostream)
525 return 1;
526
527 if(uri)
528 uri=raptor_uri_copy_v2(rdf_serializer->world, uri);
529
530 rdf_serializer->base_uri=uri;
531 rdf_serializer->locator.uri=uri;
532 rdf_serializer->locator.line=rdf_serializer->locator.column = 0;
533
534 rdf_serializer->iostream=iostream;
535
536 if(rdf_serializer->factory->serialize_start)
537 return rdf_serializer->factory->serialize_start(rdf_serializer);
538 return 0;
539 }
540
541
542 /**
543 * raptor_serialize_start:
544 * @rdf_serializer: the #raptor_serializer
545 * @uri: base URI or NULL if no base URI is required
546 * @iostream: #raptor_iostream to write serialization to
547 *
548 * Start serialization with given base URI
549 *
550 * The passed in @iostream becomes owned by the serializer and will
551 * be destroyed when the serializing is complete. Compare to
552 * raptor_serialize_start_to_iostream(). This function
553 * will be deprecated for raptor_serialize_start_to_iostream() in future.
554 *
555 * Return value: non-0 on failure.
556 **/
557 int
raptor_serialize_start(raptor_serializer * rdf_serializer,raptor_uri * uri,raptor_iostream * iostream)558 raptor_serialize_start(raptor_serializer *rdf_serializer, raptor_uri *uri,
559 raptor_iostream *iostream)
560 {
561 int rc;
562 rc=raptor_serialize_start_to_iostream(rdf_serializer, uri, iostream);
563 if(!rc)
564 rdf_serializer->free_iostream_on_end=1;
565
566 return rc;
567 }
568
569
570 /**
571 * raptor_serialize_start_to_filename:
572 * @rdf_serializer: the #raptor_serializer
573 * @filename: filename to serialize to
574 *
575 * Start serializing to a filename.
576 *
577 * Return value: non-0 on failure.
578 **/
579 int
raptor_serialize_start_to_filename(raptor_serializer * rdf_serializer,const char * filename)580 raptor_serialize_start_to_filename(raptor_serializer *rdf_serializer,
581 const char *filename)
582 {
583 unsigned char *uri_string=raptor_uri_filename_to_uri_string(filename);
584 if(!uri_string)
585 return 1;
586
587 if(rdf_serializer->base_uri)
588 raptor_free_uri_v2(rdf_serializer->world, rdf_serializer->base_uri);
589
590 rdf_serializer->base_uri=raptor_new_uri_v2(rdf_serializer->world, uri_string);
591 rdf_serializer->locator.uri=rdf_serializer->base_uri;
592 rdf_serializer->locator.line=rdf_serializer->locator.column = 0;
593
594 RAPTOR_FREE(cstring, uri_string);
595
596 rdf_serializer->iostream=raptor_new_iostream_to_filename(filename);
597 if(!rdf_serializer->iostream)
598 return 1;
599
600 rdf_serializer->free_iostream_on_end=1;
601
602 if(rdf_serializer->factory->serialize_start)
603 return rdf_serializer->factory->serialize_start(rdf_serializer);
604 return 0;
605 }
606
607
608
609 /**
610 * raptor_serialize_start_to_string:
611 * @rdf_serializer: the #raptor_serializer
612 * @uri: base URI or NULL if no base URI is required
613 * @string_p: pointer to location to hold string
614 * @length_p: pointer to location to hold length of string (or NULL)
615 *
616 * Start serializing to a string.
617 *
618 * Return value: non-0 on failure.
619 **/
620 int
raptor_serialize_start_to_string(raptor_serializer * rdf_serializer,raptor_uri * uri,void ** string_p,size_t * length_p)621 raptor_serialize_start_to_string(raptor_serializer *rdf_serializer,
622 raptor_uri *uri,
623 void **string_p, size_t *length_p)
624 {
625 if(rdf_serializer->base_uri)
626 raptor_free_uri_v2(rdf_serializer->world, rdf_serializer->base_uri);
627
628 if(uri)
629 rdf_serializer->base_uri=raptor_uri_copy_v2(rdf_serializer->world, uri);
630 else
631 rdf_serializer->base_uri=NULL;
632 rdf_serializer->locator.uri=rdf_serializer->base_uri;
633 rdf_serializer->locator.line=rdf_serializer->locator.column = 0;
634
635
636 rdf_serializer->iostream=raptor_new_iostream_to_string(string_p, length_p,
637 NULL);
638 if(!rdf_serializer->iostream)
639 return 1;
640
641 rdf_serializer->free_iostream_on_end=1;
642
643 if(rdf_serializer->factory->serialize_start)
644 return rdf_serializer->factory->serialize_start(rdf_serializer);
645 return 0;
646 }
647
648
649 /**
650 * raptor_serialize_start_to_file_handle:
651 * @rdf_serializer: the #raptor_serializer
652 * @uri: base URI or NULL if no base URI is required
653 * @fh: FILE* to serialize to
654 *
655 * Start serializing to a FILE*.
656 *
657 * NOTE: This does not fclose the handle when it is finished.
658 *
659 * Return value: non-0 on failure.
660 **/
661 int
raptor_serialize_start_to_file_handle(raptor_serializer * rdf_serializer,raptor_uri * uri,FILE * fh)662 raptor_serialize_start_to_file_handle(raptor_serializer *rdf_serializer,
663 raptor_uri *uri, FILE *fh)
664 {
665 if(rdf_serializer->base_uri)
666 raptor_free_uri_v2(rdf_serializer->world, rdf_serializer->base_uri);
667
668 if(uri)
669 rdf_serializer->base_uri=raptor_uri_copy_v2(rdf_serializer->world, uri);
670 else
671 rdf_serializer->base_uri=NULL;
672 rdf_serializer->locator.uri=rdf_serializer->base_uri;
673 rdf_serializer->locator.line=rdf_serializer->locator.column = 0;
674
675 rdf_serializer->iostream=raptor_new_iostream_to_file_handle(fh);
676 if(!rdf_serializer->iostream)
677 return 1;
678
679 rdf_serializer->free_iostream_on_end=1;
680
681 if(rdf_serializer->factory->serialize_start)
682 return rdf_serializer->factory->serialize_start(rdf_serializer);
683 return 0;
684 }
685
686
687 /**
688 * raptor_serialize_set_namespace:
689 * @rdf_serializer: the #raptor_serializer
690 * @uri: #raptor_uri of namespace or NULL
691 * @prefix: prefix to use or NULL
692 *
693 * set a namespace uri/prefix mapping for serializing.
694 *
695 * return value: non-0 on failure.
696 **/
697 int
raptor_serialize_set_namespace(raptor_serializer * rdf_serializer,raptor_uri * uri,const unsigned char * prefix)698 raptor_serialize_set_namespace(raptor_serializer* rdf_serializer,
699 raptor_uri *uri, const unsigned char *prefix)
700 {
701 if(prefix && !*prefix)
702 prefix=NULL;
703
704 if(rdf_serializer->factory->declare_namespace)
705 return rdf_serializer->factory->declare_namespace(rdf_serializer,
706 uri, prefix);
707
708 return 1;
709 }
710
711
712 /**
713 * raptor_serialize_set_namespace_from_namespace:
714 * @rdf_serializer: the #raptor_serializer
715 * @nspace: #raptor_namespace to set
716 *
717 * Set a namespace uri/prefix mapping for serializing from an existing namespace.
718 *
719 * Return value: non-0 on failure.
720 **/
721 int
raptor_serialize_set_namespace_from_namespace(raptor_serializer * rdf_serializer,raptor_namespace * nspace)722 raptor_serialize_set_namespace_from_namespace(raptor_serializer* rdf_serializer,
723 raptor_namespace *nspace)
724 {
725 if(rdf_serializer->factory->declare_namespace_from_namespace)
726 return rdf_serializer->factory->declare_namespace_from_namespace(rdf_serializer,
727 nspace);
728 else if (rdf_serializer->factory->declare_namespace)
729 return rdf_serializer->factory->declare_namespace(rdf_serializer,
730 raptor_namespace_get_uri(nspace),
731 raptor_namespace_get_prefix(nspace));
732
733 return 1;
734 }
735
736
737 /**
738 * raptor_serialize_statement:
739 * @rdf_serializer: the #raptor_serializer
740 * @statement: #raptor_statement to serialize to a syntax
741 *
742 * Serialize a statement.
743 *
744 * Return value: non-0 on failure.
745 **/
746 int
raptor_serialize_statement(raptor_serializer * rdf_serializer,const raptor_statement * statement)747 raptor_serialize_statement(raptor_serializer* rdf_serializer,
748 const raptor_statement *statement)
749 {
750 if(!rdf_serializer->iostream)
751 return 1;
752 return rdf_serializer->factory->serialize_statement(rdf_serializer, statement);
753 }
754
755
756 /**
757 * raptor_serialize_end:
758 * @rdf_serializer: the #raptor_serializer
759 *
760 * End a serialization.
761 *
762 * Return value: non-0 on failure.
763 **/
764 int
raptor_serialize_end(raptor_serializer * rdf_serializer)765 raptor_serialize_end(raptor_serializer *rdf_serializer)
766 {
767 int rc;
768
769 if(!rdf_serializer->iostream)
770 return 1;
771
772 if(rdf_serializer->factory->serialize_end)
773 rc=rdf_serializer->factory->serialize_end(rdf_serializer);
774 else
775 rc=0;
776
777 if(rdf_serializer->iostream) {
778 if(rdf_serializer->free_iostream_on_end)
779 raptor_free_iostream(rdf_serializer->iostream);
780 rdf_serializer->iostream=NULL;
781 }
782 return rc;
783 }
784
785
786
787 /**
788 * raptor_free_serializer:
789 * @rdf_serializer: #raptor_serializer object
790 *
791 * Destructor - destroy a raptor_serializer object.
792 *
793 **/
794 void
raptor_free_serializer(raptor_serializer * rdf_serializer)795 raptor_free_serializer(raptor_serializer* rdf_serializer)
796 {
797 RAPTOR_ASSERT_OBJECT_POINTER_RETURN(rdf_serializer, raptor_serializer);
798
799 if(rdf_serializer->factory)
800 rdf_serializer->factory->terminate(rdf_serializer);
801
802 if(rdf_serializer->context)
803 RAPTOR_FREE(raptor_serializer_context, rdf_serializer->context);
804
805 if(rdf_serializer->base_uri)
806 raptor_free_uri_v2(rdf_serializer->world, rdf_serializer->base_uri);
807
808 if(rdf_serializer->feature_start_uri)
809 raptor_free_uri_v2(rdf_serializer->world, rdf_serializer->feature_start_uri);
810
811 if(rdf_serializer->feature_resource_border)
812 RAPTOR_FREE(cstring, rdf_serializer->feature_resource_border);
813
814 if(rdf_serializer->feature_literal_border)
815 RAPTOR_FREE(cstring, rdf_serializer->feature_literal_border);
816
817 if(rdf_serializer->feature_bnode_border)
818 RAPTOR_FREE(cstring, rdf_serializer->feature_bnode_border);
819
820 if(rdf_serializer->feature_resource_fill)
821 RAPTOR_FREE(cstring, rdf_serializer->feature_resource_fill);
822
823 if(rdf_serializer->feature_literal_fill)
824 RAPTOR_FREE(cstring, rdf_serializer->feature_literal_fill);
825
826 if(rdf_serializer->feature_bnode_fill)
827 RAPTOR_FREE(cstring, rdf_serializer->feature_bnode_fill);
828
829 if(rdf_serializer->feature_json_callback)
830 RAPTOR_FREE(cstring, rdf_serializer->feature_json_callback);
831
832 if(rdf_serializer->feature_json_extra_data)
833 RAPTOR_FREE(cstring, rdf_serializer->feature_json_extra_data);
834
835 if(rdf_serializer->feature_rss_triples)
836 RAPTOR_FREE(cstring, rdf_serializer->feature_rss_triples);
837
838 if(rdf_serializer->feature_atom_entry_uri)
839 RAPTOR_FREE(cstring, rdf_serializer->feature_atom_entry_uri);
840
841 RAPTOR_FREE(raptor_serializer, rdf_serializer);
842 }
843
844
845 /**
846 * raptor_serializer_get_iostream:
847 * @serializer: #raptor_serializer object
848 *
849 * Get the current serializer iostream.
850 *
851 * Return value: the serializer's current iostream or NULL if
852 **/
853 raptor_iostream*
raptor_serializer_get_iostream(raptor_serializer * serializer)854 raptor_serializer_get_iostream(raptor_serializer *serializer)
855 {
856 return serializer->iostream;
857 }
858
859
860 #ifndef RAPTOR_DISABLE_V1
861 /**
862 * raptor_serializer_features_enumerate:
863 * @feature: feature enumeration (0+)
864 * @name: pointer to store feature short name (or NULL)
865 * @uri: pointer to store feature URI (or NULL)
866 * @label: pointer to feature label (or NULL)
867 *
868 * Get list of serializer features.
869 *
870 * If uri is not NULL, a pointer toa new raptor_uri is returned
871 * that must be freed by the caller with raptor_free_uri().
872 *
873 * raptor_init() MUST have been called before calling this function.
874 * Use raptor_serializer_features_enumerate_v2() if using raptor_world APIs.
875 *
876 * Return value: 0 on success, <0 on failure, >0 if feature is unknown
877 **/
878 int
raptor_serializer_features_enumerate(const raptor_feature feature,const char ** name,raptor_uri ** uri,const char ** label)879 raptor_serializer_features_enumerate(const raptor_feature feature,
880 const char **name,
881 raptor_uri **uri, const char **label)
882 {
883 return raptor_serializer_features_enumerate_v2(raptor_world_instance(),
884 feature, name, uri, label);
885 }
886 #endif
887
888
889 /**
890 * raptor_serializer_features_enumerate_v2:
891 * @world: raptor_world object
892 * @feature: feature enumeration (0+)
893 * @name: pointer to store feature short name (or NULL)
894 * @uri: pointer to store feature URI (or NULL)
895 * @label: pointer to feature label (or NULL)
896 *
897 * Get list of serializer features.
898 *
899 * If uri is not NULL, a pointer toa new raptor_uri is returned
900 * that must be freed by the caller with raptor_free_uri_v2().
901 *
902 * Return value: 0 on success, <0 on failure, >0 if feature is unknown
903 **/
904 int
raptor_serializer_features_enumerate_v2(raptor_world * world,const raptor_feature feature,const char ** name,raptor_uri ** uri,const char ** label)905 raptor_serializer_features_enumerate_v2(raptor_world* world,
906 const raptor_feature feature,
907 const char **name,
908 raptor_uri **uri, const char **label)
909 {
910 return raptor_features_enumerate_common(world, feature, name, uri, label, 2);
911 }
912
913
914 /**
915 * raptor_serializer_set_feature:
916 * @serializer: #raptor_serializer serializer object
917 * @feature: feature to set from enumerated #raptor_feature values
918 * @value: integer feature value (0 or larger)
919 *
920 * Set serializer features with integer values.
921 *
922 * The allowed features are available via raptor_features_enumerate().
923 *
924 * Return value: non 0 on failure or if the feature is unknown
925 **/
926 int
raptor_serializer_set_feature(raptor_serializer * serializer,raptor_feature feature,int value)927 raptor_serializer_set_feature(raptor_serializer *serializer,
928 raptor_feature feature, int value)
929 {
930 if(value < 0)
931 return -1;
932
933 switch(feature) {
934 case RAPTOR_FEATURE_WRITE_BASE_URI:
935 serializer->feature_write_base_uri=value;
936 break;
937
938 case RAPTOR_FEATURE_RELATIVE_URIS:
939 serializer->feature_relative_uris=value;
940 break;
941
942 case RAPTOR_FEATURE_START_URI:
943 return -1;
944 break;
945
946 case RAPTOR_FEATURE_WRITER_XML_VERSION:
947 if(value == 10 || value == 11)
948 serializer->xml_version=value;
949 break;
950
951 case RAPTOR_FEATURE_WRITER_XML_DECLARATION:
952 serializer->feature_write_xml_declaration = value;
953 break;
954
955 case RAPTOR_FEATURE_PREFIX_ELEMENTS:
956 serializer->feature_prefix_elements = value;
957 break;
958
959 /* parser features */
960 case RAPTOR_FEATURE_SCANNING:
961 case RAPTOR_FEATURE_ASSUME_IS_RDF:
962 case RAPTOR_FEATURE_ALLOW_NON_NS_ATTRIBUTES:
963 case RAPTOR_FEATURE_ALLOW_OTHER_PARSETYPES:
964 case RAPTOR_FEATURE_ALLOW_BAGID:
965 case RAPTOR_FEATURE_ALLOW_RDF_TYPE_RDF_LIST:
966 case RAPTOR_FEATURE_NORMALIZE_LANGUAGE:
967 case RAPTOR_FEATURE_NON_NFC_FATAL:
968 case RAPTOR_FEATURE_WARN_OTHER_PARSETYPES:
969 case RAPTOR_FEATURE_CHECK_RDF_ID:
970 case RAPTOR_FEATURE_HTML_TAG_SOUP:
971 case RAPTOR_FEATURE_MICROFORMATS:
972 case RAPTOR_FEATURE_HTML_LINK:
973 case RAPTOR_FEATURE_WWW_TIMEOUT:
974
975 /* Shared */
976 case RAPTOR_FEATURE_NO_NET:
977 case RAPTOR_FEATURE_LOAD_EXTERNAL_ENTITIES:
978
979 /* XML writer features */
980 case RAPTOR_FEATURE_WRITER_AUTO_INDENT:
981 case RAPTOR_FEATURE_WRITER_AUTO_EMPTY:
982 case RAPTOR_FEATURE_WRITER_INDENT_WIDTH:
983
984 /* String features */
985 case RAPTOR_FEATURE_RESOURCE_BORDER:
986 case RAPTOR_FEATURE_LITERAL_BORDER:
987 case RAPTOR_FEATURE_BNODE_BORDER:
988 case RAPTOR_FEATURE_RESOURCE_FILL:
989 case RAPTOR_FEATURE_LITERAL_FILL:
990 case RAPTOR_FEATURE_BNODE_FILL:
991 case RAPTOR_FEATURE_JSON_CALLBACK:
992 case RAPTOR_FEATURE_JSON_EXTRA_DATA:
993 case RAPTOR_FEATURE_RSS_TRIPLES:
994 case RAPTOR_FEATURE_ATOM_ENTRY_URI:
995
996 /* WWW features */
997 case RAPTOR_FEATURE_WWW_HTTP_CACHE_CONTROL:
998 case RAPTOR_FEATURE_WWW_HTTP_USER_AGENT:
999
1000 default:
1001 return -1;
1002 break;
1003 }
1004
1005 return 0;
1006 }
1007
1008
1009 static int
raptor_serializer_copy_string(unsigned char ** dest,const unsigned char * src)1010 raptor_serializer_copy_string(unsigned char ** dest,
1011 const unsigned char * src)
1012 {
1013 size_t src_len=strlen((const char *)src);
1014
1015 if(*dest) {
1016 RAPTOR_FREE(cstring, *dest);
1017 *dest=NULL;
1018 }
1019
1020 if(!(*dest=(unsigned char*)RAPTOR_MALLOC(cstring, src_len+1)))
1021 return -1;
1022
1023 strcpy((char *)(*dest), (const char *)src);
1024
1025 return 0;
1026 }
1027
1028
1029 /**
1030 * raptor_serializer_set_feature_string:
1031 * @serializer: #raptor_serializer serializer object
1032 * @feature: feature to set from enumerated #raptor_feature values
1033 * @value: feature value
1034 *
1035 * Set serializer features with string values.
1036 *
1037 * The allowed features are available via raptor_serializer_features_enumerate().
1038 * If the feature type is integer, the value is interpreted as an integer.
1039 *
1040 * Return value: non 0 on failure or if the feature is unknown
1041 **/
1042 int
raptor_serializer_set_feature_string(raptor_serializer * serializer,raptor_feature feature,const unsigned char * value)1043 raptor_serializer_set_feature_string(raptor_serializer *serializer,
1044 raptor_feature feature,
1045 const unsigned char *value)
1046 {
1047 int value_is_string=(raptor_feature_value_type(feature) == 1);
1048 if(!value_is_string)
1049 return raptor_serializer_set_feature(serializer, feature,
1050 atoi((const char*)value));
1051
1052 switch(feature) {
1053 case RAPTOR_FEATURE_START_URI:
1054 if(value)
1055 serializer->feature_start_uri=raptor_new_uri_v2(serializer->world, value);
1056 else
1057 return -1;
1058 break;
1059
1060 case RAPTOR_FEATURE_WRITE_BASE_URI:
1061 case RAPTOR_FEATURE_RELATIVE_URIS:
1062 case RAPTOR_FEATURE_PREFIX_ELEMENTS:
1063 /* actually handled above because value_is_string is false */
1064 return -1;
1065 break;
1066
1067 /* parser features */
1068 case RAPTOR_FEATURE_SCANNING:
1069 case RAPTOR_FEATURE_ASSUME_IS_RDF:
1070 case RAPTOR_FEATURE_ALLOW_NON_NS_ATTRIBUTES:
1071 case RAPTOR_FEATURE_ALLOW_OTHER_PARSETYPES:
1072 case RAPTOR_FEATURE_ALLOW_BAGID:
1073 case RAPTOR_FEATURE_ALLOW_RDF_TYPE_RDF_LIST:
1074 case RAPTOR_FEATURE_NORMALIZE_LANGUAGE:
1075 case RAPTOR_FEATURE_NON_NFC_FATAL:
1076 case RAPTOR_FEATURE_WARN_OTHER_PARSETYPES:
1077 case RAPTOR_FEATURE_CHECK_RDF_ID:
1078 case RAPTOR_FEATURE_HTML_TAG_SOUP:
1079 case RAPTOR_FEATURE_MICROFORMATS:
1080 case RAPTOR_FEATURE_HTML_LINK:
1081 case RAPTOR_FEATURE_WWW_TIMEOUT:
1082
1083 /* Shared */
1084 case RAPTOR_FEATURE_NO_NET:
1085 case RAPTOR_FEATURE_LOAD_EXTERNAL_ENTITIES:
1086
1087 /* XML writer features */
1088 case RAPTOR_FEATURE_WRITER_AUTO_INDENT:
1089 case RAPTOR_FEATURE_WRITER_AUTO_EMPTY:
1090 case RAPTOR_FEATURE_WRITER_INDENT_WIDTH:
1091 case RAPTOR_FEATURE_WRITER_XML_VERSION:
1092 case RAPTOR_FEATURE_WRITER_XML_DECLARATION:
1093
1094 /* GraphViz serializer features */
1095 case RAPTOR_FEATURE_RESOURCE_BORDER:
1096 return raptor_serializer_copy_string(
1097 (unsigned char **)&(serializer->feature_resource_border), value);
1098 break;
1099 case RAPTOR_FEATURE_LITERAL_BORDER:
1100 return raptor_serializer_copy_string(
1101 (unsigned char **)&(serializer->feature_literal_border), value);
1102 break;
1103 case RAPTOR_FEATURE_BNODE_BORDER:
1104 return raptor_serializer_copy_string(
1105 (unsigned char **)&(serializer->feature_bnode_border), value);
1106 break;
1107 case RAPTOR_FEATURE_RESOURCE_FILL:
1108 return raptor_serializer_copy_string(
1109 (unsigned char **)&(serializer->feature_resource_fill), value);
1110 break;
1111 case RAPTOR_FEATURE_LITERAL_FILL:
1112 return raptor_serializer_copy_string(
1113 (unsigned char **)&(serializer->feature_literal_fill), value);
1114 break;
1115 case RAPTOR_FEATURE_BNODE_FILL:
1116 return raptor_serializer_copy_string(
1117 (unsigned char **)&(serializer->feature_bnode_fill), value);
1118 break;
1119
1120 /* JSON serializer features */
1121 case RAPTOR_FEATURE_JSON_CALLBACK:
1122 return raptor_serializer_copy_string(
1123 (unsigned char **)&(serializer->feature_json_callback), value);
1124 break;
1125
1126 case RAPTOR_FEATURE_JSON_EXTRA_DATA:
1127 return raptor_serializer_copy_string(
1128 (unsigned char **)&(serializer->feature_json_extra_data), value);
1129 break;
1130
1131 case RAPTOR_FEATURE_RSS_TRIPLES:
1132 return raptor_serializer_copy_string(
1133 (unsigned char **)&(serializer->feature_rss_triples), value);
1134 break;
1135
1136 case RAPTOR_FEATURE_ATOM_ENTRY_URI:
1137 return raptor_serializer_copy_string(
1138 (unsigned char **)&(serializer->feature_atom_entry_uri), value);
1139 break;
1140
1141 /* WWW features */
1142 case RAPTOR_FEATURE_WWW_HTTP_CACHE_CONTROL:
1143 case RAPTOR_FEATURE_WWW_HTTP_USER_AGENT:
1144
1145 default:
1146 return -1;
1147 break;
1148 }
1149
1150 return 0;
1151 }
1152
1153
1154 /**
1155 * raptor_serializer_get_feature:
1156 * @serializer: #raptor_serializer serializer object
1157 * @feature: feature to get value
1158 *
1159 * Get various serializer features.
1160 *
1161 * The allowed features are available via raptor_features_enumerate().
1162 *
1163 * Note: no feature value is negative
1164 *
1165 * Return value: feature value or < 0 for an illegal feature
1166 **/
1167 int
raptor_serializer_get_feature(raptor_serializer * serializer,raptor_feature feature)1168 raptor_serializer_get_feature(raptor_serializer *serializer,
1169 raptor_feature feature)
1170 {
1171 int result= -1;
1172
1173 switch(feature) {
1174 case RAPTOR_FEATURE_WRITE_BASE_URI:
1175 result=(serializer->feature_write_base_uri != 0);
1176 break;
1177
1178 case RAPTOR_FEATURE_RELATIVE_URIS:
1179 result=(serializer->feature_relative_uris != 0);
1180 break;
1181
1182 /* String features */
1183 case RAPTOR_FEATURE_START_URI:
1184 case RAPTOR_FEATURE_RESOURCE_BORDER:
1185 case RAPTOR_FEATURE_LITERAL_BORDER:
1186 case RAPTOR_FEATURE_BNODE_BORDER:
1187 case RAPTOR_FEATURE_RESOURCE_FILL:
1188 case RAPTOR_FEATURE_LITERAL_FILL:
1189 case RAPTOR_FEATURE_BNODE_FILL:
1190 case RAPTOR_FEATURE_JSON_CALLBACK:
1191 case RAPTOR_FEATURE_JSON_EXTRA_DATA:
1192 case RAPTOR_FEATURE_RSS_TRIPLES:
1193 case RAPTOR_FEATURE_ATOM_ENTRY_URI:
1194 result= -1;
1195 break;
1196
1197 case RAPTOR_FEATURE_PREFIX_ELEMENTS:
1198 result = serializer->feature_prefix_elements;
1199 break;
1200
1201 case RAPTOR_FEATURE_WRITER_XML_VERSION:
1202 result=serializer->xml_version;
1203 break;
1204
1205 case RAPTOR_FEATURE_WRITER_XML_DECLARATION:
1206 result=serializer->feature_write_xml_declaration;
1207 break;
1208
1209 /* parser features */
1210 case RAPTOR_FEATURE_SCANNING:
1211 case RAPTOR_FEATURE_ASSUME_IS_RDF:
1212 case RAPTOR_FEATURE_ALLOW_NON_NS_ATTRIBUTES:
1213 case RAPTOR_FEATURE_ALLOW_OTHER_PARSETYPES:
1214 case RAPTOR_FEATURE_ALLOW_BAGID:
1215 case RAPTOR_FEATURE_ALLOW_RDF_TYPE_RDF_LIST:
1216 case RAPTOR_FEATURE_NORMALIZE_LANGUAGE:
1217 case RAPTOR_FEATURE_NON_NFC_FATAL:
1218 case RAPTOR_FEATURE_WARN_OTHER_PARSETYPES:
1219 case RAPTOR_FEATURE_CHECK_RDF_ID:
1220 case RAPTOR_FEATURE_HTML_TAG_SOUP:
1221 case RAPTOR_FEATURE_MICROFORMATS:
1222 case RAPTOR_FEATURE_HTML_LINK:
1223 case RAPTOR_FEATURE_WWW_TIMEOUT:
1224
1225 /* Shared */
1226 case RAPTOR_FEATURE_NO_NET:
1227 case RAPTOR_FEATURE_LOAD_EXTERNAL_ENTITIES:
1228
1229 /* XML writer features */
1230 case RAPTOR_FEATURE_WRITER_AUTO_INDENT:
1231 case RAPTOR_FEATURE_WRITER_AUTO_EMPTY:
1232 case RAPTOR_FEATURE_WRITER_INDENT_WIDTH:
1233
1234 /* WWW features */
1235 case RAPTOR_FEATURE_WWW_HTTP_CACHE_CONTROL:
1236 case RAPTOR_FEATURE_WWW_HTTP_USER_AGENT:
1237
1238 default:
1239 break;
1240 }
1241
1242 return result;
1243 }
1244
1245
1246 /**
1247 * raptor_serializer_get_feature_string:
1248 * @serializer: #raptor_serializer serializer object
1249 * @feature: feature to get value
1250 *
1251 * Get serializer features with string values.
1252 *
1253 * The allowed features are available via raptor_features_enumerate().
1254 *
1255 * Return value: feature value or NULL for an illegal feature or no value
1256 **/
1257 const unsigned char *
raptor_serializer_get_feature_string(raptor_serializer * serializer,raptor_feature feature)1258 raptor_serializer_get_feature_string(raptor_serializer *serializer,
1259 raptor_feature feature)
1260 {
1261 int value_is_string=(raptor_feature_value_type(feature) == 1);
1262 if(!value_is_string)
1263 return NULL;
1264
1265 switch(feature) {
1266 case RAPTOR_FEATURE_START_URI:
1267 if(serializer->feature_start_uri)
1268 return raptor_uri_to_string_v2(serializer->world, serializer->feature_start_uri);
1269 break;
1270
1271 case RAPTOR_FEATURE_WRITE_BASE_URI:
1272 case RAPTOR_FEATURE_RELATIVE_URIS:
1273 /* actually handled above because value_is_string is false */
1274 return NULL;
1275 break;
1276
1277 /* GraphViz serializer features */
1278 case RAPTOR_FEATURE_RESOURCE_BORDER:
1279 return (unsigned char *)(serializer->feature_resource_border);
1280 break;
1281 case RAPTOR_FEATURE_LITERAL_BORDER:
1282 return (unsigned char *)(serializer->feature_literal_border);
1283 break;
1284 case RAPTOR_FEATURE_BNODE_BORDER:
1285 return (unsigned char *)(serializer->feature_bnode_border);
1286 break;
1287 case RAPTOR_FEATURE_RESOURCE_FILL:
1288 return (unsigned char *)(serializer->feature_resource_fill);
1289 break;
1290 case RAPTOR_FEATURE_LITERAL_FILL:
1291 return (unsigned char *)(serializer->feature_literal_fill);
1292 break;
1293 case RAPTOR_FEATURE_BNODE_FILL:
1294 return (unsigned char *)(serializer->feature_bnode_fill);
1295 break;
1296 case RAPTOR_FEATURE_JSON_CALLBACK:
1297 return (unsigned char *)(serializer->feature_json_callback);
1298 break;
1299 case RAPTOR_FEATURE_JSON_EXTRA_DATA:
1300 return (unsigned char *)(serializer->feature_json_extra_data);
1301 break;
1302 case RAPTOR_FEATURE_RSS_TRIPLES:
1303 return (unsigned char *)(serializer->feature_rss_triples);
1304 break;
1305 case RAPTOR_FEATURE_ATOM_ENTRY_URI:
1306 return (unsigned char *)(serializer->feature_atom_entry_uri);
1307 break;
1308 case RAPTOR_FEATURE_PREFIX_ELEMENTS:
1309 return NULL;
1310 break;
1311
1312 /* parser features */
1313 case RAPTOR_FEATURE_SCANNING:
1314 case RAPTOR_FEATURE_ASSUME_IS_RDF:
1315 case RAPTOR_FEATURE_ALLOW_NON_NS_ATTRIBUTES:
1316 case RAPTOR_FEATURE_ALLOW_OTHER_PARSETYPES:
1317 case RAPTOR_FEATURE_ALLOW_BAGID:
1318 case RAPTOR_FEATURE_ALLOW_RDF_TYPE_RDF_LIST:
1319 case RAPTOR_FEATURE_NORMALIZE_LANGUAGE:
1320 case RAPTOR_FEATURE_NON_NFC_FATAL:
1321 case RAPTOR_FEATURE_WARN_OTHER_PARSETYPES:
1322 case RAPTOR_FEATURE_CHECK_RDF_ID:
1323 case RAPTOR_FEATURE_HTML_TAG_SOUP:
1324 case RAPTOR_FEATURE_MICROFORMATS:
1325 case RAPTOR_FEATURE_HTML_LINK:
1326 case RAPTOR_FEATURE_WWW_TIMEOUT:
1327
1328 /* Shared */
1329 case RAPTOR_FEATURE_NO_NET:
1330 case RAPTOR_FEATURE_LOAD_EXTERNAL_ENTITIES:
1331
1332 /* XML writer features */
1333 case RAPTOR_FEATURE_WRITER_AUTO_INDENT:
1334 case RAPTOR_FEATURE_WRITER_AUTO_EMPTY:
1335 case RAPTOR_FEATURE_WRITER_INDENT_WIDTH:
1336 case RAPTOR_FEATURE_WRITER_XML_VERSION:
1337 case RAPTOR_FEATURE_WRITER_XML_DECLARATION:
1338
1339 /* WWW features */
1340 case RAPTOR_FEATURE_WWW_HTTP_CACHE_CONTROL:
1341 case RAPTOR_FEATURE_WWW_HTTP_USER_AGENT:
1342
1343 default:
1344 return NULL;
1345 break;
1346 }
1347
1348 return NULL;
1349 }
1350
1351
1352 /*
1353 * raptor_serializer_error - Error from a serializer - Internal
1354 */
1355 void
raptor_serializer_error(raptor_serializer * serializer,const char * message,...)1356 raptor_serializer_error(raptor_serializer* serializer, const char *message, ...)
1357 {
1358 va_list arguments;
1359
1360 va_start(arguments, message);
1361
1362 raptor_serializer_error_varargs(serializer, message, arguments);
1363
1364 va_end(arguments);
1365 }
1366
1367
1368 /*
1369 * raptor_serializer_simple_error - Error from a serializer - Internal
1370 *
1371 * Matches the raptor_simple_message_handler API but same as
1372 * raptor_serializer_error
1373 */
1374 void
raptor_serializer_simple_error(void * serializer,const char * message,...)1375 raptor_serializer_simple_error(void* serializer, const char *message, ...)
1376 {
1377 va_list arguments;
1378
1379 va_start(arguments, message);
1380
1381 raptor_serializer_error_varargs((raptor_serializer*)serializer, message, arguments);
1382
1383 va_end(arguments);
1384 }
1385
1386
1387 /*
1388 * raptor_serializer_error_varargs - Error from a serializer - Internal
1389 */
1390 void
raptor_serializer_error_varargs(raptor_serializer * serializer,const char * message,va_list arguments)1391 raptor_serializer_error_varargs(raptor_serializer* serializer,
1392 const char *message,
1393 va_list arguments)
1394 {
1395 if(serializer->error_handler) {
1396 char *buffer=raptor_vsnprintf(message, arguments);
1397 size_t length;
1398 if(!buffer) {
1399 fprintf(stderr, "raptor_serializer_error_varargs: Out of memory\n");
1400 return;
1401 }
1402 length=strlen(buffer);
1403 if(buffer[length-1]=='\n')
1404 buffer[length-1]='\0';
1405 serializer->error_handler(serializer->error_user_data,
1406 &serializer->locator, buffer);
1407 RAPTOR_FREE(cstring, buffer);
1408 return;
1409 }
1410
1411 raptor_print_locator_v2(serializer->world, stderr, &serializer->locator);
1412 fprintf(stderr, " raptor error - ");
1413 vfprintf(stderr, message, arguments);
1414 fputc('\n', stderr);
1415 }
1416
1417
1418 /*
1419 * raptor_serializer_warning - Warning from a serializer - Internal
1420 */
1421 void
raptor_serializer_warning(raptor_serializer * serializer,const char * message,...)1422 raptor_serializer_warning(raptor_serializer* serializer, const char *message, ...)
1423 {
1424 va_list arguments;
1425
1426 va_start(arguments, message);
1427
1428 raptor_serializer_warning_varargs(serializer, message, arguments);
1429
1430 va_end(arguments);
1431 }
1432
1433
1434 /*
1435 * raptor_serializer_warning - Warning from a serializer - Internal
1436 */
1437 void
raptor_serializer_warning_varargs(raptor_serializer * serializer,const char * message,va_list arguments)1438 raptor_serializer_warning_varargs(raptor_serializer* serializer, const char *message,
1439 va_list arguments)
1440 {
1441
1442 if(serializer->warning_handler) {
1443 char *buffer=raptor_vsnprintf(message, arguments);
1444 size_t length;
1445 if(!buffer) {
1446 fprintf(stderr, "raptor_serializer_warning_varargs: Out of memory\n");
1447 return;
1448 }
1449 length=strlen(buffer);
1450 if(buffer[length-1]=='\n')
1451 buffer[length-1]='\0';
1452 serializer->warning_handler(serializer->warning_user_data,
1453 &serializer->locator, buffer);
1454 RAPTOR_FREE(cstring, buffer);
1455 return;
1456 }
1457
1458 raptor_print_locator_v2(serializer->world, stderr, &serializer->locator);
1459 fprintf(stderr, " raptor warning - ");
1460 vfprintf(stderr, message, arguments);
1461 fputc('\n', stderr);
1462 }
1463
1464
1465 /**
1466 * raptor_serializer_set_error_handler:
1467 * @serializer: the serializer
1468 * @user_data: user data to pass to function
1469 * @handler: pointer to the function
1470 *
1471 * Set the serializer error handling function.
1472 *
1473 * The function will receive callbacks when the serializer fails.
1474 *
1475 **/
1476 void
raptor_serializer_set_error_handler(raptor_serializer * serializer,void * user_data,raptor_message_handler handler)1477 raptor_serializer_set_error_handler(raptor_serializer* serializer,
1478 void *user_data,
1479 raptor_message_handler handler)
1480 {
1481 serializer->error_user_data=user_data;
1482 serializer->error_handler=handler;
1483 }
1484
1485
1486 /**
1487 * raptor_serializer_set_warning_handler:
1488 * @serializer: the serializer
1489 * @user_data: user data to pass to function
1490 * @handler: pointer to the function
1491 *
1492 * Set the serializer warning handling function.
1493 *
1494 * The function will receive callbacks when the serializer fails.
1495 *
1496 **/
1497 void
raptor_serializer_set_warning_handler(raptor_serializer * serializer,void * user_data,raptor_message_handler handler)1498 raptor_serializer_set_warning_handler(raptor_serializer* serializer,
1499 void *user_data,
1500 raptor_message_handler handler)
1501 {
1502 serializer->warning_user_data=user_data;
1503 serializer->warning_handler=handler;
1504 }
1505
1506
1507 /**
1508 * raptor_serializer_get_locator:
1509 * @rdf_serializer: raptor serializer
1510 *
1511 * Get the serializer raptor locator object.
1512 *
1513 * Return value: raptor locator
1514 **/
1515 raptor_locator*
raptor_serializer_get_locator(raptor_serializer * rdf_serializer)1516 raptor_serializer_get_locator(raptor_serializer *rdf_serializer)
1517 {
1518 return &rdf_serializer->locator;
1519 }
1520
1521
1522 /**
1523 * raptor_serializer_get_world:
1524 * @rdf_serializer: raptor serializer
1525 *
1526 * Get the #raptor_world object associated with a serializer.
1527 *
1528 * Return value: raptor_world* pointer
1529 **/
1530 raptor_world *
raptor_serializer_get_world(raptor_serializer * rdf_serializer)1531 raptor_serializer_get_world(raptor_serializer* rdf_serializer)
1532 {
1533 return rdf_serializer->world;
1534 }
1535