← Back to branch summary

~ubuntu-branches/ubuntu/natty/raptor/natty-updates

« back to all changes in this revision

Viewing changes to src/raptor_serialize.c

  • Committer: Bazaar Package Importer
  • Author(s): Dave Beckett
  • Date: 2008-04-01 22:06:01 UTC
  • mfrom: (1.1.8 upstream) (2.1.3 lenny)
  • Revision ID: james.westby@ubuntu.com-20080401220601-4h1tzxtwyziurokj
Tags: 1.4.17-1
http://bugs.debian.org/463344
* New upstream release
* Rebuild against libcurl4-gnutls-dev rather than libcurl4-openssl-dev
  (Closes: #463344)
* debian/control: depend on libtool 1.5 rather than older debian specific
  release
* debian/copyright: 2008
* debian/libraptor1-doc.doc-base: Use a correct Section:

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/raptor_serialize.c
82
82
 
83
83
/* class methods */
84
84
 
85
 
void
 
85
int
86
86
raptor_serializers_init(void)
87
87
{
 
88
  int rc=0;
 
89
 
88
90
  serializers=raptor_new_sequence((raptor_sequence_free_handler *)raptor_free_serializer_factory, NULL);
89
 
  if(!serializers) {
90
 
    raptor_finish();
91
 
    RAPTOR_FATAL1("Out of memory\n");
92
 
  }
 
91
  if(!serializers)
 
92
    return 1;
93
93
 
94
94
  /* raptor_init_serializer_simple(); */
95
95
 
96
96
#ifdef RAPTOR_SERIALIZER_NTRIPLES
97
 
  raptor_init_serializer_ntriples();
 
97
  rc+= raptor_init_serializer_ntriples() != 0;
98
98
#endif
99
99
 
100
100
#ifdef RAPTOR_SERIALIZER_TURTLE
101
 
  raptor_init_serializer_turtle();
 
101
  rc+= raptor_init_serializer_turtle() != 0;
102
102
#endif
103
103
 
104
104
#ifdef RAPTOR_SERIALIZER_RDFXML_ABBREV
105
 
  raptor_init_serializer_rdfxmla();
 
105
  rc+= raptor_init_serializer_rdfxmla() != 0;
106
106
#endif
107
107
 
108
108
#ifdef RAPTOR_SERIALIZER_RDFXML
109
 
  raptor_init_serializer_rdfxml();
 
109
  rc+= raptor_init_serializer_rdfxml() != 0;
110
110
#endif
111
111
 
112
112
#ifdef RAPTOR_SERIALIZER_RSS_1_0
113
 
  raptor_init_serializer_rss10();
 
113
  rc+= raptor_init_serializer_rss10() != 0;
114
114
#endif
115
115
 
116
116
#ifdef RAPTOR_SERIALIZER_ATOM
117
 
  raptor_init_serializer_atom();
 
117
  rc+= raptor_init_serializer_atom() != 0;
118
118
#endif
119
119
 
120
120
#ifdef RAPTOR_SERIALIZER_DOT
121
 
  raptor_init_serializer_dot();
122
 
#endif
 
121
  rc+= raptor_init_serializer_dot() != 0;
 
122
#endif
 
123
 
 
124
#ifdef RAPTOR_SERIALIZER_JSON
 
125
  rc+= raptor_init_serializer_json() != 0;
 
126
#endif
 
127
 
 
128
  return rc;
123
129
}
124
130
 
125
131
 
146
152
 * 
147
153
 * INTERNAL
148
154
 *
 
155
 * Return value: non-0 on failure
149
156
 **/
150
 
void
 
157
int
151
158
raptor_serializer_register_factory(const char *name, const char *label,
152
159
                                   const char *mime_type,
153
160
                                   const char *alias,
154
161
                                   const unsigned char *uri_string,
155
 
                                   void (*factory) (raptor_serializer_factory*)) 
 
162
                                   int (*factory) (raptor_serializer_factory*)) 
156
163
{
157
164
  raptor_serializer_factory *serializer;
158
165
  char *name_copy, *label_copy, *mime_type_copy, *alias_copy;
172
179
      i++) {
173
180
    if(!strcmp(serializer->name, name)) {
174
181
      RAPTOR_FATAL2("serializer %s already registered\n", name);
175
 
      return;
 
182
      return 1;
176
183
    }
177
184
  }
178
185
  
180
187
  serializer=(raptor_serializer_factory*)RAPTOR_CALLOC(raptor_serializer_factory, 1,
181
188
                                               sizeof(raptor_serializer_factory));
182
189
  if(!serializer)
183
 
    goto fail_noserializer;
 
190
    return 1;
184
191
 
185
192
  name_copy=(char*)RAPTOR_CALLOC(cstring, strlen(name)+1, 1);
186
193
  if(!name_copy)
187
 
    goto fail;
 
194
    goto tidy;
188
195
  strcpy(name_copy, name);
189
196
  serializer->name=name_copy;
190
197
        
191
198
  label_copy=(char*)RAPTOR_CALLOC(cstring, strlen(label)+1, 1);
192
199
  if(!label_copy)
193
 
    goto fail;
 
200
    goto tidy;
194
201
  strcpy(label_copy, label);
195
202
  serializer->label=label_copy;
196
203
 
197
204
  if(mime_type) {
198
205
    mime_type_copy=(char*)RAPTOR_CALLOC(cstring, strlen(mime_type)+1, 1);
199
206
    if(!mime_type_copy)
200
 
      goto fail;
 
207
      goto tidy;
201
208
    strcpy(mime_type_copy, mime_type);
202
209
    serializer->mime_type=mime_type_copy;
203
210
  }
205
212
  if(uri_string) {
206
213
    uri_string_copy=(unsigned char*)RAPTOR_CALLOC(cstring, strlen((const char*)uri_string)+1, 1);
207
214
    if(!uri_string_copy)
208
 
      goto fail;
 
215
      goto tidy;
209
216
    strcpy((char*)uri_string_copy, (const char*)uri_string);
210
217
    serializer->uri_string=uri_string_copy;
211
218
  }
213
220
  if(alias) {
214
221
    alias_copy=(char*)RAPTOR_CALLOC(cstring, strlen(alias)+1, 1);
215
222
    if(!alias_copy)
216
 
      goto fail;
 
223
      goto tidy;
217
224
    strcpy(alias_copy, alias);
218
225
    serializer->alias=alias_copy;
219
226
  }
220
227
 
221
228
  if(raptor_sequence_push(serializers, serializer))
222
 
    goto fail_noserializer; /* on error, serializer is already freed by the sequence */
 
229
    return 1; /* on error, serializer is already freed by the sequence */
223
230
 
224
231
  /* Call the serializer registration function on the new object */
225
 
  (*factory)(serializer);
 
232
  if (factory(serializer))
 
233
    return 1; /* serializer is owned and freed by the serializers sequence */
226
234
  
227
235
#if defined(RAPTOR_DEBUG) && RAPTOR_DEBUG > 1
228
236
  RAPTOR_DEBUG3("%s has context size %d\n", name, serializer->context_length);
229
237
#endif
230
238
 
231
 
  return;
 
239
  return 0;
232
240
 
233
241
  /* Clean up on failure */
234
 
  fail:
 
242
  tidy:
235
243
  raptor_free_serializer_factory(serializer);
236
 
  fail_noserializer:
237
 
  raptor_finish();
238
 
  RAPTOR_FATAL1("Out of memory\n");
 
244
  return 1;
239
245
}
240
246
 
241
247
 
369
375
  rdf_serializer->factory=factory;
370
376
 
371
377
  /* Default features */
 
378
  
 
379
  /* Emit @base directive or equivalent */
 
380
  rdf_serializer->feature_write_base_uri=1;
 
381
  
372
382
  /* Emit relative URIs where possible */
373
383
  rdf_serializer->feature_relative_uris=1;
374
384
 
385
395
  /* Write XML declaration */
386
396
  rdf_serializer->feature_write_xml_declaration=1;
387
397
 
 
398
  /* JSON callback function name */
 
399
  rdf_serializer->feature_json_callback= NULL;
 
400
 
 
401
  /* JSON extra data */
 
402
  rdf_serializer->feature_json_extra_data= NULL;
 
403
 
388
404
  if(factory->init(rdf_serializer, name)) {
389
405
    raptor_free_serializer(rdf_serializer);
390
406
    return NULL;
658
674
  if(rdf_serializer->feature_start_uri)
659
675
    raptor_free_uri(rdf_serializer->feature_start_uri);
660
676
 
 
677
  if(rdf_serializer->feature_resource_border)
 
678
    RAPTOR_FREE(cstring, rdf_serializer->feature_resource_border);
 
679
  
 
680
  if(rdf_serializer->feature_literal_border)
 
681
    RAPTOR_FREE(cstring, rdf_serializer->feature_literal_border);
 
682
  
 
683
  if(rdf_serializer->feature_bnode_border)
 
684
    RAPTOR_FREE(cstring, rdf_serializer->feature_bnode_border);
 
685
  
 
686
  if(rdf_serializer->feature_resource_fill)
 
687
    RAPTOR_FREE(cstring, rdf_serializer->feature_resource_fill);
 
688
  
 
689
  if(rdf_serializer->feature_literal_fill)
 
690
    RAPTOR_FREE(cstring, rdf_serializer->feature_literal_fill);
 
691
  
 
692
  if(rdf_serializer->feature_bnode_fill)
 
693
    RAPTOR_FREE(cstring, rdf_serializer->feature_bnode_fill);
 
694
  
 
695
  if(rdf_serializer->feature_json_callback)
 
696
    RAPTOR_FREE(cstring, rdf_serializer->feature_json_callback);
 
697
 
 
698
  if(rdf_serializer->feature_json_extra_data)
 
699
    RAPTOR_FREE(cstring, rdf_serializer->feature_json_extra_data);
 
700
 
661
701
  RAPTOR_FREE(raptor_serializer, rdf_serializer);
662
702
}
663
703
 
721
761
    return -1;
722
762
  
723
763
  switch(feature) {
 
764
    case RAPTOR_FEATURE_WRITE_BASE_URI:
 
765
      serializer->feature_write_base_uri=value;
 
766
      break;
 
767
 
724
768
    case RAPTOR_FEATURE_RELATIVE_URIS:
725
769
      serializer->feature_relative_uris=value;
726
770
      break;
769
813
    case RAPTOR_FEATURE_RESOURCE_FILL:
770
814
    case RAPTOR_FEATURE_LITERAL_FILL:
771
815
    case RAPTOR_FEATURE_BNODE_FILL:
 
816
    case RAPTOR_FEATURE_JSON_CALLBACK:
 
817
    case RAPTOR_FEATURE_JSON_EXTRA_DATA:
 
818
 
 
819
    /* WWW features */
 
820
    case RAPTOR_FEATURE_WWW_HTTP_CACHE_CONTROL:
 
821
    case RAPTOR_FEATURE_WWW_HTTP_USER_AGENT:
772
822
 
773
823
    default:
774
824
      return -1;
830
880
        return -1;
831
881
      break;
832
882
 
 
883
    case RAPTOR_FEATURE_WRITE_BASE_URI:
833
884
    case RAPTOR_FEATURE_RELATIVE_URIS:
834
885
      /* actually handled above because value_is_string is false */
835
886
      return -1;
887
938
        (unsigned char **)&(serializer->feature_bnode_fill), value);
888
939
      break;
889
940
 
 
941
    /* JSON serializer features */
 
942
    case RAPTOR_FEATURE_JSON_CALLBACK:
 
943
      return raptor_serializer_copy_string(
 
944
        (unsigned char **)&(serializer->feature_json_callback), value);
 
945
      break;
 
946
 
 
947
    case RAPTOR_FEATURE_JSON_EXTRA_DATA:
 
948
      return raptor_serializer_copy_string(
 
949
        (unsigned char **)&(serializer->feature_json_extra_data), value);
 
950
      break;
 
951
 
 
952
    /* WWW features */
 
953
    case RAPTOR_FEATURE_WWW_HTTP_CACHE_CONTROL:
 
954
    case RAPTOR_FEATURE_WWW_HTTP_USER_AGENT:
 
955
 
890
956
    default:
891
957
      return -1;
892
958
      break;
916
982
  int result= -1;
917
983
  
918
984
  switch(feature) {
 
985
    case RAPTOR_FEATURE_WRITE_BASE_URI:
 
986
      result=(serializer->feature_write_base_uri != 0);
 
987
      break;
 
988
 
919
989
    case RAPTOR_FEATURE_RELATIVE_URIS:
920
990
      result=(serializer->feature_relative_uris != 0);
921
991
      break;
928
998
    case RAPTOR_FEATURE_RESOURCE_FILL:
929
999
    case RAPTOR_FEATURE_LITERAL_FILL:
930
1000
    case RAPTOR_FEATURE_BNODE_FILL:
 
1001
    case RAPTOR_FEATURE_JSON_CALLBACK:
 
1002
    case RAPTOR_FEATURE_JSON_EXTRA_DATA:
931
1003
      result= -1;
932
1004
      break;
933
1005
 
963
1035
    case RAPTOR_FEATURE_WRITER_AUTO_EMPTY:
964
1036
    case RAPTOR_FEATURE_WRITER_INDENT_WIDTH:
965
1037
 
 
1038
    /* WWW features */
 
1039
    case RAPTOR_FEATURE_WWW_HTTP_CACHE_CONTROL:
 
1040
    case RAPTOR_FEATURE_WWW_HTTP_USER_AGENT:
 
1041
 
966
1042
    default:
967
1043
      break;
968
1044
  }
996
1072
        return raptor_uri_to_string(serializer->feature_start_uri);
997
1073
      break;
998
1074
 
 
1075
    case RAPTOR_FEATURE_WRITE_BASE_URI:
999
1076
    case RAPTOR_FEATURE_RELATIVE_URIS:
1000
1077
      /* actually handled above because value_is_string is false */
1001
1078
      return NULL;
1020
1097
    case RAPTOR_FEATURE_BNODE_FILL:
1021
1098
      return (unsigned char *)(serializer->feature_bnode_fill);
1022
1099
      break;
 
1100
    case RAPTOR_FEATURE_JSON_CALLBACK:
 
1101
      return (unsigned char *)(serializer->feature_json_callback);
 
1102
      break;
 
1103
    case RAPTOR_FEATURE_JSON_EXTRA_DATA:
 
1104
      return (unsigned char *)(serializer->feature_json_extra_data);
 
1105
      break;
1023
1106
        
1024
1107
    /* parser features */
1025
1108
    case RAPTOR_FEATURE_SCANNING:
1047
1130
    case RAPTOR_FEATURE_WRITER_XML_VERSION:
1048
1131
    case RAPTOR_FEATURE_WRITER_XML_DECLARATION:
1049
1132
 
 
1133
    /* WWW features */
 
1134
    case RAPTOR_FEATURE_WWW_HTTP_CACHE_CONTROL:
 
1135
    case RAPTOR_FEATURE_WWW_HTTP_USER_AGENT:
 
1136
 
1050
1137
    default:
1051
1138
      return NULL;
1052
1139
      break;