libxml-ruby 2.3.3-x86-mingw32 → 2.4.0-x86-mingw32

Sign up to get free protection for your applications and to get access to all the features.
data/HISTORY CHANGED
@@ -1,5 +1,16 @@
1
1
  = Release History
2
2
 
3
+ == 2.4.0 / 2012-12-14 Charlie Savage
4
+
5
+ * Support libxml 2.9.0 (Daniel Veillard)
6
+
7
+ * Extensive new interfaces for xml schema functionality including suppor for
8
+ schemal elements, types, facets and attributes (Anton Sozontov)
9
+
10
+ * Fix Encoding#from_s bug and update docs (Nikita Afanasenko)
11
+
12
+ * Node#content= encoding (Nikita Afanasenko)
13
+
3
14
  == 2.3.3 / 2012-07-01 Charlie Savage
4
15
 
5
16
  * Add LibXML::XML::Error.get_handler (Carsten Zimmermann)
@@ -229,8 +229,7 @@ rxml_document_canonicalize(int argc, VALUE *argv, VALUE self)
229
229
  VALUE o_comments = Qnil;
230
230
  VALUE o_mode = Qnil;
231
231
  VALUE o_i_ns_prefixes = Qnil;
232
- VALUE * list_in = NULL;
233
-
232
+
234
233
  Check_Type(option_hash, T_HASH);
235
234
 
236
235
  o_comments = rb_hash_aref(option_hash, ID2SYM(rb_intern("comments")));
@@ -328,7 +327,7 @@ rxml_document_canonicalize(int argc, VALUE *argv, VALUE self)
328
327
  xdoc,
329
328
  (nodeset.nodeNr == 0 ? NULL : &nodeset),
330
329
  c14n_mode,
331
- &inc_ns_prefixes_ptr,
330
+ inc_ns_prefixes_ptr,
332
331
  comments,
333
332
  &buffer
334
333
  );
@@ -41,7 +41,7 @@ VALUE mXMLEncoding;
41
41
 
42
42
  /*
43
43
  * call-seq:
44
- * Input.s_to_encoding("UTF_8") -> XML::Encoding::UTF_8
44
+ * Encoding.from_s("UTF_8") -> XML::Encoding::UTF_8
45
45
  *
46
46
  * Converts an encoding string to an encoding constant
47
47
  * defined on the XML::Encoding class.
@@ -49,17 +49,17 @@ VALUE mXMLEncoding;
49
49
  static VALUE rxml_encoding_from_s(VALUE klass, VALUE encoding)
50
50
  {
51
51
  xmlCharEncoding xencoding;
52
-
52
+
53
53
  if (encoding == Qnil)
54
54
  return Qnil;
55
55
 
56
56
  xencoding = xmlParseCharEncoding(StringValuePtr(encoding));
57
- return NUM2INT(xencoding);
57
+ return INT2NUM(xencoding);
58
58
  }
59
59
 
60
60
  /*
61
61
  * call-seq:
62
- * Input.encoding_to_s(Input::ENCODING) -> "encoding"
62
+ * Encoding.to_s(XML::Encoding::UTF_8) -> "UTF-8"
63
63
  *
64
64
  * Converts an encoding constant defined on the XML::Encoding
65
65
  * class to its text representation.
@@ -397,11 +397,12 @@ static VALUE rxml_node_content_get(VALUE self)
397
397
  static VALUE rxml_node_content_set(VALUE self, VALUE content)
398
398
  {
399
399
  xmlNodePtr xnode;
400
+ xmlChar* encoded_content;
400
401
 
401
402
  Check_Type(content, T_STRING);
402
403
  xnode = rxml_get_xnode(self);
403
- // XXX docs indicate need for escaping entites, need to be done? danj
404
- xmlNodeSetContent(xnode, (xmlChar*) StringValuePtr(content));
404
+ encoded_content = xmlEncodeSpecialChars(xnode->doc, (xmlChar*) StringValuePtr(content));
405
+ xmlNodeSetContent(xnode, encoded_content);
405
406
  return (Qtrue);
406
407
  }
407
408
 
@@ -618,10 +619,17 @@ static VALUE rxml_node_to_s(int argc, VALUE *argv, VALUE self)
618
619
  xmlNodeDumpOutput(output, xnode->doc, xnode, level, indent, xencoding);
619
620
  xmlOutputBufferFlush(output);
620
621
 
622
+ #ifdef LIBXML2_NEW_BUFFER
623
+ if (output->conv)
624
+ result = rxml_new_cstr((const char*) xmlBufContent(output->conv), xencoding);
625
+ else
626
+ result = rxml_new_cstr((const char*) xmlBufContent(output->buffer), xencoding);
627
+ #else
621
628
  if (output->conv)
622
629
  result = rxml_new_cstr((const char*) output->conv->content, xencoding);
623
630
  else
624
631
  result = rxml_new_cstr((const char*) output->buffer->content, xencoding);
632
+ #endif
625
633
 
626
634
  xmlOutputBufferClose(output);
627
635
 
@@ -1,6 +1,14 @@
1
1
  #include "ruby_libxml.h"
2
+ #define LIBXML_OUTPUT_ENABLED
3
+ #define DUMP_CONTENT_MODEL
2
4
  #include "ruby_xml_schema.h"
3
5
 
6
+ #include "ruby_xml_schema_type.h"
7
+ #include "ruby_xml_schema_element.h"
8
+ #include "ruby_xml_schema_attribute.h"
9
+ #include "ruby_xml_schema_facet.h"
10
+
11
+
4
12
  /*
5
13
  * Document-class: LibXML::XML::Schema
6
14
  *
@@ -37,6 +45,12 @@ static void rxml_schema_free(xmlSchemaPtr xschema)
37
45
  xmlSchemaFree(xschema);
38
46
  }
39
47
 
48
+ VALUE rxml_wrap_schema(xmlSchemaPtr xschema)
49
+ {
50
+ return Data_Wrap_Struct(cXMLSchema, NULL, rxml_schema_free, xschema);
51
+ }
52
+
53
+
40
54
  /*
41
55
  * call-seq:
42
56
  * XML::Schema.initialize(schema_uri) -> schema
@@ -99,10 +113,186 @@ static VALUE rxml_schema_init_from_string(VALUE self, VALUE schema_str)
99
113
  return Data_Wrap_Struct(cXMLSchema, NULL, rxml_schema_free, xschema);
100
114
  }
101
115
 
116
+
117
+ static VALUE rxml_schema_target_namespace(VALUE self)
118
+ {
119
+ xmlSchemaPtr xschema;
120
+
121
+ Data_Get_Struct(self, xmlSchema, xschema);
122
+
123
+ QNIL_OR_STRING(xschema->targetNamespace)
124
+ }
125
+
126
+ static VALUE rxml_schema_name(VALUE self)
127
+ {
128
+ xmlSchemaPtr xschema;
129
+
130
+ Data_Get_Struct(self, xmlSchema, xschema);
131
+
132
+ QNIL_OR_STRING(xschema->name)
133
+ }
134
+
135
+ static VALUE rxml_schema_version(VALUE self)
136
+ {
137
+ xmlSchemaPtr xschema;
138
+
139
+ Data_Get_Struct(self, xmlSchema, xschema);
140
+
141
+ QNIL_OR_STRING(xschema->version)
142
+ }
143
+
144
+ static VALUE rxml_schema_id(VALUE self)
145
+ {
146
+ xmlSchemaPtr xschema;
147
+
148
+ Data_Get_Struct(self, xmlSchema, xschema);
149
+
150
+ QNIL_OR_STRING(xschema->id)
151
+ }
152
+
153
+
154
+ static VALUE rxml_schema_document(VALUE self)
155
+ {
156
+ xmlSchemaPtr xschema;
157
+
158
+ Data_Get_Struct(self, xmlSchema, xschema);
159
+
160
+ return rxml_node_wrap(xmlDocGetRootElement(xschema->doc));
161
+ }
162
+
163
+ static void storeNs(xmlSchemaImportPtr import, VALUE self, xmlChar *nsname)
164
+ {
165
+ VALUE schemas;
166
+ xmlNodePtr xnode;
167
+ xmlNsPtr xns;
168
+
169
+ schemas = rb_iv_get(self, "@namespaces");
170
+ if (import->doc) {
171
+ xnode = xmlDocGetRootElement(import->doc);
172
+
173
+ xns = xnode->nsDef;
174
+
175
+ while (xns) {
176
+ VALUE anamespace = rxml_namespace_wrap(xns);
177
+ rb_ary_push(schemas, anamespace);
178
+ xns = xns->next;
179
+ }
180
+ }
181
+ }
182
+
183
+ static VALUE rxml_schema_namespaces(VALUE self)
184
+ {
185
+ VALUE schemas;
186
+ xmlSchemaPtr xschema;
187
+
188
+ Data_Get_Struct(self, xmlSchema, xschema);
189
+
190
+ if (rb_iv_get(self, "@namespaces") == Qnil) {
191
+ schemas = rb_ary_new();
192
+ rb_iv_set(self, "@namespaces", schemas);
193
+ xmlHashScan(xschema->schemasImports, (xmlHashScanner) storeNs, (void *)self);
194
+ }
195
+
196
+ return rb_iv_get(self, "@namespaces");
197
+ }
198
+
199
+ static void storeType(xmlSchemaTypePtr type, VALUE self, xmlChar *name)
200
+ {
201
+ VALUE types;
202
+ VALUE rtype;
203
+
204
+ types = rb_iv_get(self, "@types");
205
+ rtype = rxml_wrap_schema_type(type);
206
+
207
+ rb_hash_aset(types, rb_str_new2(name), rtype);
208
+ }
209
+
210
+ static VALUE rxml_schema_collect_types(VALUE self);
211
+
212
+ static VALUE rxml_schema_types(VALUE self)
213
+ {
214
+ VALUE types;
215
+ xmlSchemaPtr xschema;
216
+
217
+ Data_Get_Struct(self, xmlSchema, xschema);
218
+
219
+ if (rb_iv_get(self, "@types") == Qnil) {
220
+ types = rb_hash_new();
221
+ rb_iv_set(self, "@types", types);
222
+ rxml_schema_collect_types(self);
223
+ if(xschema != NULL && xschema->typeDecl != NULL)
224
+ xmlHashScan(xschema->typeDecl, (xmlHashScanner) storeType, (void *)self);
225
+ }
226
+
227
+ return rb_iv_get(self, "@types");
228
+ }
229
+
230
+ static void storeElement(xmlSchemaElementPtr element, VALUE self, xmlChar *name)
231
+ {
232
+ VALUE elements;
233
+ VALUE relement;
234
+
235
+ elements = rb_iv_get(self, "@elements");
236
+ relement = rxml_wrap_schema_element(element);
237
+ rb_hash_aset(elements, rb_str_new2(name), relement);
238
+ }
239
+
240
+ static VALUE rxml_schema_elements(VALUE self)
241
+ {
242
+ VALUE elements;
243
+ xmlSchemaPtr xschema;
244
+
245
+ Data_Get_Struct(self, xmlSchema, xschema);
246
+
247
+ if (rb_iv_get(self, "@elements") == Qnil) {
248
+ elements = rb_hash_new();
249
+ rb_iv_set(self, "@elements", elements);
250
+ xmlHashScan(xschema->elemDecl, (xmlHashScanner) storeElement, (void *)self);
251
+ }
252
+
253
+ return rb_iv_get(self, "@elements");
254
+ }
255
+
256
+ static void collectSchemaTypes(xmlSchemaImportPtr import, VALUE self)
257
+ {
258
+ if (import->imported && import->schema) {
259
+ xmlHashScan(import->schema->typeDecl, (xmlHashScanner) storeType, (void *)self);
260
+ }
261
+ }
262
+
263
+ static VALUE rxml_schema_collect_types(VALUE self)
264
+ {
265
+ xmlSchemaPtr xschema;
266
+
267
+ Data_Get_Struct(self, xmlSchema, xschema);
268
+
269
+ if(xschema){
270
+ xmlHashScan(xschema->schemasImports, (xmlHashScanner) collectSchemaTypes, (void *)self);
271
+ }
272
+
273
+ return Qnil;
274
+ }
275
+
102
276
  void rxml_init_schema(void)
103
277
  {
104
278
  cXMLSchema = rb_define_class_under(mXML, "Schema", rb_cObject);
105
279
  rb_define_singleton_method(cXMLSchema, "new", rxml_schema_init_from_uri, 1);
106
280
  rb_define_singleton_method(cXMLSchema, "from_string", rxml_schema_init_from_string, 1);
107
281
  rb_define_singleton_method(cXMLSchema, "document", rxml_schema_init_from_document, 1);
282
+
283
+ rb_define_method(cXMLSchema, "target_namespace", rxml_schema_target_namespace, 0);
284
+ rb_define_method(cXMLSchema, "name", rxml_schema_name, 0);
285
+ rb_define_method(cXMLSchema, "id", rxml_schema_id, 0);
286
+ rb_define_method(cXMLSchema, "version", rxml_schema_version, 0);
287
+ rb_define_method(cXMLSchema, "document", rxml_schema_document, 0);
288
+
289
+ rb_define_method(cXMLSchema, "_namespaces", rxml_schema_namespaces, 0);
290
+ rb_define_method(cXMLSchema, "_collect_types", rxml_schema_collect_types, 0);
291
+ rb_define_method(cXMLSchema, "types", rxml_schema_types, 0);
292
+ rb_define_method(cXMLSchema, "elements", rxml_schema_elements, 0);
293
+
294
+ rxml_init_schema_facet();
295
+ rxml_init_schema_element();
296
+ rxml_init_schema_attribute();
297
+ rxml_init_schema_type();
108
298
  }
@@ -3,9 +3,807 @@
3
3
 
4
4
  #include <libxml/schemasInternals.h>
5
5
  #include <libxml/xmlschemas.h>
6
+ #include <libxml/xmlschemastypes.h>
6
7
 
7
8
  extern VALUE cXMLSchema;
8
9
 
9
- void rxml_init_schema(void);
10
+ void rxml_init_schema(void);
11
+
12
+ #define QNIL_OR_STRING(slot) \
13
+ if (slot == NULL) \
14
+ return Qnil; \
15
+ else \
16
+ return rb_str_new2((const char *)slot);
17
+
18
+ #define SUBSET_RESTRICTION 1<<0
19
+ #define SUBSET_EXTENSION 1<<1
20
+ #define SUBSET_SUBSTITUTION 1<<2
21
+ #define SUBSET_LIST 1<<3
22
+ #define SUBSET_UNION 1<<4
23
+
24
+ typedef struct _xmlSchemaNodeInfo xmlSchemaNodeInfo;
25
+ typedef xmlSchemaNodeInfo *xmlSchemaNodeInfoPtr;
26
+
27
+ typedef struct _xmlSchemaItemList xmlSchemaItemList;
28
+ typedef xmlSchemaItemList *xmlSchemaItemListPtr;
29
+ struct _xmlSchemaItemList {
30
+ void **items;
31
+ /* used for dynamic addition of schemata */
32
+ int nbItems;
33
+ /* used for dynamic addition of schemata */
34
+ int sizeItems; /* used for dynamic addition of schemata */
35
+ };
36
+
37
+ #define XML_SCHEMA_CTXT_PARSER 1
38
+ #define XML_SCHEMA_CTXT_VALIDATOR 2
39
+
40
+ typedef struct _xmlSchemaAbstractCtxt xmlSchemaAbstractCtxt;
41
+ typedef xmlSchemaAbstractCtxt *xmlSchemaAbstractCtxtPtr;
42
+ struct _xmlSchemaAbstractCtxt {
43
+ int type; /* E.g. XML_SCHEMA_CTXT_VALIDATOR */
44
+ };
45
+
46
+ typedef struct _xmlSchemaBucket xmlSchemaBucket;
47
+ typedef xmlSchemaBucket *xmlSchemaBucketPtr;
48
+
49
+ #define XML_SCHEMA_SCHEMA_MAIN 0
50
+ #define XML_SCHEMA_SCHEMA_IMPORT 1
51
+ #define XML_SCHEMA_SCHEMA_INCLUDE 2
52
+ #define XML_SCHEMA_SCHEMA_REDEFINE 3
53
+
54
+ /**
55
+ * xmlSchemaSchemaRelation:
56
+ *
57
+ * Used to create a graph of schema relationships.
58
+ */
59
+ typedef struct _xmlSchemaSchemaRelation xmlSchemaSchemaRelation;
60
+ typedef xmlSchemaSchemaRelation *xmlSchemaSchemaRelationPtr;
61
+ struct _xmlSchemaSchemaRelation {
62
+ xmlSchemaSchemaRelationPtr next;
63
+ int type;
64
+ /* E.g. XML_SCHEMA_SCHEMA_IMPORT */
65
+ const xmlChar *importNamespace;
66
+ xmlSchemaBucketPtr bucket;
67
+ };
68
+
69
+ #define XML_SCHEMA_BUCKET_MARKED 1<<0
70
+ #define XML_SCHEMA_BUCKET_COMPS_ADDED 1<<1
71
+
72
+ struct _xmlSchemaBucket {
73
+ int type;
74
+ int flags;
75
+ const xmlChar *schemaLocation;
76
+ const xmlChar *origTargetNamespace;
77
+ const xmlChar *targetNamespace;
78
+ xmlDocPtr doc;
79
+ xmlSchemaSchemaRelationPtr relations;
80
+ int located;
81
+ int parsed;
82
+ int imported;
83
+ int preserveDoc;
84
+ xmlSchemaItemListPtr globals;
85
+ /* Global components. */
86
+ xmlSchemaItemListPtr locals; /* Local components. */
87
+ };
88
+
89
+ /**
90
+ * xmlSchemaImport:
91
+ * (extends xmlSchemaBucket)
92
+ *
93
+ * Reflects a schema. Holds some information
94
+ * about the schema and its toplevel components. Duplicate
95
+ * toplevel components are not checked at this level.
96
+ */
97
+ typedef struct _xmlSchemaImport xmlSchemaImport;
98
+ typedef xmlSchemaImport *xmlSchemaImportPtr;
99
+ struct _xmlSchemaImport {
100
+ int type;
101
+ /* Main OR import OR include. */
102
+ int flags;
103
+ const xmlChar *schemaLocation; /* The URI of the schema document. */
104
+ /* For chameleon includes, @origTargetNamespace will be NULL */
105
+ const xmlChar *origTargetNamespace;
106
+ /*
107
+ * For chameleon includes, @targetNamespace will be the
108
+ * targetNamespace of the including schema.
109
+ */
110
+ const xmlChar *targetNamespace;
111
+ xmlDocPtr doc; /* The schema node-tree. */
112
+ /* @relations will hold any included/imported/redefined schemas. */
113
+ xmlSchemaSchemaRelationPtr relations;
114
+ int located;
115
+ int parsed;
116
+ int imported;
117
+ int preserveDoc;
118
+ xmlSchemaItemListPtr globals;
119
+ xmlSchemaItemListPtr locals;
120
+ /* The imported schema. */
121
+ xmlSchemaPtr schema;
122
+ };
123
+
124
+ /*
125
+ * (extends xmlSchemaBucket)
126
+ */
127
+ typedef struct _xmlSchemaInclude xmlSchemaInclude;
128
+ typedef xmlSchemaInclude *xmlSchemaIncludePtr;
129
+ struct _xmlSchemaInclude {
130
+ int type;
131
+ int flags;
132
+ const xmlChar *schemaLocation;
133
+ const xmlChar *origTargetNamespace;
134
+ const xmlChar *targetNamespace;
135
+ xmlDocPtr doc;
136
+ xmlSchemaSchemaRelationPtr relations;
137
+ int located;
138
+ int parsed;
139
+ int imported;
140
+ int preserveDoc;
141
+ xmlSchemaItemListPtr globals;
142
+ /* Global components. */
143
+ xmlSchemaItemListPtr locals; /* Local components. */
144
+
145
+ /* The owning main or import schema bucket. */
146
+ xmlSchemaImportPtr ownerImport;
147
+ };
148
+
149
+ /**
150
+ * xmlSchemaBasicItem:
151
+ *
152
+ * The abstract base type for schema components.
153
+ */
154
+ typedef struct _xmlSchemaBasicItem xmlSchemaBasicItem;
155
+ typedef xmlSchemaBasicItem *xmlSchemaBasicItemPtr;
156
+ struct _xmlSchemaBasicItem {
157
+ xmlSchemaTypeType type;
158
+ };
159
+
160
+ /**
161
+ * xmlSchemaAnnotItem:
162
+ *
163
+ * The abstract base type for annotated schema components.
164
+ * (Extends xmlSchemaBasicItem)
165
+ */
166
+ typedef struct _xmlSchemaAnnotItem xmlSchemaAnnotItem;
167
+ typedef xmlSchemaAnnotItem *xmlSchemaAnnotItemPtr;
168
+ struct _xmlSchemaAnnotItem {
169
+ xmlSchemaTypeType type;
170
+ xmlSchemaAnnotPtr annot;
171
+ };
172
+
173
+ /**
174
+ * xmlSchemaTreeItem:
175
+ *
176
+ * The abstract base type for tree-like structured schema components.
177
+ * (Extends xmlSchemaAnnotItem)
178
+ */
179
+ typedef struct _xmlSchemaTreeItem xmlSchemaTreeItem;
180
+ typedef xmlSchemaTreeItem *xmlSchemaTreeItemPtr;
181
+ struct _xmlSchemaTreeItem {
182
+ xmlSchemaTypeType type;
183
+ xmlSchemaAnnotPtr annot;
184
+ xmlSchemaTreeItemPtr next;
185
+ xmlSchemaTreeItemPtr children;
186
+ };
187
+
188
+
189
+ #define XML_SCHEMA_ATTR_USE_FIXED 1<<0
190
+ /**
191
+ * xmlSchemaAttributeUsePtr:
192
+ *
193
+ * The abstract base type for tree-like structured schema components.
194
+ * (Extends xmlSchemaTreeItem)
195
+ */
196
+ typedef struct _xmlSchemaAttributeUse xmlSchemaAttributeUse;
197
+ typedef xmlSchemaAttributeUse *xmlSchemaAttributeUsePtr;
198
+ struct _xmlSchemaAttributeUse {
199
+ xmlSchemaTypeType type;
200
+ xmlSchemaAnnotPtr annot;
201
+ xmlSchemaAttributeUsePtr next; /* The next attr. use. */
202
+ /*
203
+ * The attr. decl. OR a QName-ref. to an attr. decl. OR
204
+ * a QName-ref. to an attribute group definition.
205
+ */
206
+ xmlSchemaAttributePtr attrDecl;
207
+
208
+ int flags;
209
+ xmlNodePtr node;
210
+ int occurs;
211
+ /* required, optional */
212
+ const xmlChar *defValue;
213
+ xmlSchemaValPtr defVal;
214
+ };
215
+
216
+ /**
217
+ * xmlSchemaAttributeUseProhibPtr:
218
+ *
219
+ * A helper component to reflect attribute prohibitions.
220
+ * (Extends xmlSchemaBasicItem)
221
+ */
222
+ typedef struct _xmlSchemaAttributeUseProhib xmlSchemaAttributeUseProhib;
223
+ typedef xmlSchemaAttributeUseProhib *xmlSchemaAttributeUseProhibPtr;
224
+ struct _xmlSchemaAttributeUseProhib {
225
+ xmlSchemaTypeType type;
226
+ /* == XML_SCHEMA_EXTRA_ATTR_USE_PROHIB */
227
+ xmlNodePtr node;
228
+ const xmlChar *name;
229
+ const xmlChar *targetNamespace;
230
+ int isRef;
231
+ };
232
+
233
+ /**
234
+ * xmlSchemaRedef:
235
+ */
236
+ typedef struct _xmlSchemaRedef xmlSchemaRedef;
237
+ typedef xmlSchemaRedef *xmlSchemaRedefPtr;
238
+ struct _xmlSchemaRedef {
239
+ xmlSchemaRedefPtr next;
240
+ xmlSchemaBasicItemPtr item;
241
+ /* The redefining component. */
242
+ xmlSchemaBasicItemPtr reference;
243
+ /* The referencing component. */
244
+ xmlSchemaBasicItemPtr target;
245
+ /* The to-be-redefined component. */
246
+ const xmlChar *refName;
247
+ /* The name of the to-be-redefined component. */
248
+ const xmlChar *refTargetNs;
249
+ /* The target namespace of the
250
+ to-be-redefined comp. */
251
+ xmlSchemaBucketPtr targetBucket; /* The redefined schema. */
252
+ };
253
+
254
+ /**
255
+ * xmlSchemaConstructionCtxt:
256
+ */
257
+ typedef struct _xmlSchemaConstructionCtxt xmlSchemaConstructionCtxt;
258
+ typedef xmlSchemaConstructionCtxt *xmlSchemaConstructionCtxtPtr;
259
+ struct _xmlSchemaConstructionCtxt {
260
+ xmlSchemaPtr mainSchema;
261
+ /* The main schema. */
262
+ xmlSchemaBucketPtr mainBucket;
263
+ /* The main schema bucket */
264
+ xmlDictPtr dict;
265
+ xmlSchemaItemListPtr buckets; /* List of schema buckets. */
266
+ /* xmlSchemaItemListPtr relations; */ /* List of schema relations. */
267
+ xmlSchemaBucketPtr bucket;
268
+ /* The current schema bucket */
269
+ xmlSchemaItemListPtr pending;
270
+ /* All Components of all schemas that
271
+ need to be fixed. */
272
+ xmlHashTablePtr substGroups;
273
+ xmlSchemaRedefPtr redefs;
274
+ xmlSchemaRedefPtr lastRedef;
275
+ };
276
+
277
+ #define XML_SCHEMAS_PARSE_ERROR 1
278
+ #define SCHEMAS_PARSE_OPTIONS XML_PARSE_NOENT
279
+
280
+ struct _xmlSchemaParserCtxt {
281
+ int type;
282
+ void *errCtxt;
283
+ /* user specific error context */
284
+ xmlSchemaValidityErrorFunc error;
285
+ /* the callback in case of errors */
286
+ xmlSchemaValidityWarningFunc warning;
287
+ /* the callback in case of warning */
288
+ int err;
289
+ int nberrors;
290
+ xmlStructuredErrorFunc serror;
291
+
292
+ xmlSchemaConstructionCtxtPtr constructor;
293
+ int ownsConstructor; /* TODO: Move this to parser *flags*. */
294
+
295
+ /* xmlSchemaPtr topschema; */
296
+ /* xmlHashTablePtr namespaces; */
297
+
298
+ xmlSchemaPtr schema;
299
+ /* The main schema in use */
300
+ int counter;
301
+
302
+ const xmlChar *URL;
303
+ xmlDocPtr doc;
304
+ int preserve;
305
+ /* Whether the doc should be freed */
306
+
307
+ const char *buffer;
308
+ int size;
309
+
310
+ /*
311
+ * Used to build complex element content models
312
+ */
313
+ xmlAutomataPtr am;
314
+ xmlAutomataStatePtr start;
315
+ xmlAutomataStatePtr end;
316
+ xmlAutomataStatePtr state;
317
+
318
+ xmlDictPtr dict;
319
+ /* dictionnary for interned string names */
320
+ xmlSchemaTypePtr ctxtType;
321
+ /* The current context simple/complex type */
322
+ int options;
323
+ xmlSchemaValidCtxtPtr vctxt;
324
+ int isS4S;
325
+ int isRedefine;
326
+ int xsiAssemble;
327
+ int stop;
328
+ /* If the parser should stop; i.e. a critical error. */
329
+ const xmlChar *targetNamespace;
330
+ xmlSchemaBucketPtr redefined;
331
+ /* The schema to be redefined. */
332
+
333
+ xmlSchemaRedefPtr redef;
334
+ /* Used for redefinitions. */
335
+ int redefCounter;
336
+ /* Used for redefinitions. */
337
+ xmlSchemaItemListPtr attrProhibs;
338
+ };
339
+
340
+ /**
341
+ * xmlSchemaQNameRef:
342
+ *
343
+ * A component reference item (not a schema component)
344
+ * (Extends xmlSchemaBasicItem)
345
+ */
346
+ typedef struct _xmlSchemaQNameRef xmlSchemaQNameRef;
347
+ typedef xmlSchemaQNameRef *xmlSchemaQNameRefPtr;
348
+ struct _xmlSchemaQNameRef {
349
+ xmlSchemaTypeType type;
350
+ xmlSchemaBasicItemPtr item;
351
+ /* The resolved referenced item. */
352
+ xmlSchemaTypeType itemType;
353
+ const xmlChar *name;
354
+ const xmlChar *targetNamespace;
355
+ xmlNodePtr node;
356
+ };
357
+
358
+ /**
359
+ * xmlSchemaParticle:
360
+ *
361
+ * A particle component.
362
+ * (Extends xmlSchemaTreeItem)
363
+ */
364
+ typedef struct _xmlSchemaParticle xmlSchemaParticle;
365
+ typedef xmlSchemaParticle *xmlSchemaParticlePtr;
366
+ struct _xmlSchemaParticle {
367
+ xmlSchemaTypeType type;
368
+ xmlSchemaAnnotPtr annot;
369
+ xmlSchemaTreeItemPtr next;
370
+ /* next particle */
371
+ xmlSchemaTreeItemPtr children;
372
+ /* the "term" (e.g. a model group,
373
+ a group definition, a XML_SCHEMA_EXTRA_QNAMEREF (if a reference),
374
+ etc.) */
375
+ int minOccurs;
376
+ int maxOccurs;
377
+ xmlNodePtr node;
378
+ };
379
+
380
+ /**
381
+ * xmlSchemaModelGroup:
382
+ *
383
+ * A model group component.
384
+ * (Extends xmlSchemaTreeItem)
385
+ */
386
+ typedef struct _xmlSchemaModelGroup xmlSchemaModelGroup;
387
+ typedef xmlSchemaModelGroup *xmlSchemaModelGroupPtr;
388
+ struct _xmlSchemaModelGroup {
389
+ xmlSchemaTypeType type;
390
+ /* XML_SCHEMA_TYPE_SEQUENCE, XML_SCHEMA_TYPE_CHOICE, XML_SCHEMA_TYPE_ALL */
391
+ xmlSchemaAnnotPtr annot;
392
+ xmlSchemaTreeItemPtr next;
393
+ /* not used */
394
+ xmlSchemaTreeItemPtr children;
395
+ /* first particle (OR "element decl" OR "wildcard") */
396
+ xmlNodePtr node;
397
+ };
398
+
399
+ #define XML_SCHEMA_MODEL_GROUP_DEF_MARKED 1<<0
400
+ #define XML_SCHEMA_MODEL_GROUP_DEF_REDEFINED 1<<1
401
+ /**
402
+ * xmlSchemaModelGroupDef:
403
+ *
404
+ * A model group definition component.
405
+ * (Extends xmlSchemaTreeItem)
406
+ */
407
+ typedef struct _xmlSchemaModelGroupDef xmlSchemaModelGroupDef;
408
+ typedef xmlSchemaModelGroupDef *xmlSchemaModelGroupDefPtr;
409
+ struct _xmlSchemaModelGroupDef {
410
+ xmlSchemaTypeType type;
411
+ /* XML_SCHEMA_TYPE_GROUP */
412
+ xmlSchemaAnnotPtr annot;
413
+ xmlSchemaTreeItemPtr next;
414
+ /* not used */
415
+ xmlSchemaTreeItemPtr children;
416
+ /* the "model group" */
417
+ const xmlChar *name;
418
+ const xmlChar *targetNamespace;
419
+ xmlNodePtr node;
420
+ int flags;
421
+ };
422
+
423
+ typedef struct _xmlSchemaIDC xmlSchemaIDC;
424
+ typedef xmlSchemaIDC *xmlSchemaIDCPtr;
425
+
426
+ /**
427
+ * xmlSchemaIDCSelect:
428
+ *
429
+ * The identity-constraint "field" and "selector" item, holding the
430
+ * XPath expression.
431
+ */
432
+ typedef struct _xmlSchemaIDCSelect xmlSchemaIDCSelect;
433
+ typedef xmlSchemaIDCSelect *xmlSchemaIDCSelectPtr;
434
+ struct _xmlSchemaIDCSelect {
435
+ xmlSchemaIDCSelectPtr next;
436
+ xmlSchemaIDCPtr idc;
437
+ int index;
438
+ /* an index position if significant for IDC key-sequences */
439
+ const xmlChar *xpath;
440
+ /* the XPath expression */
441
+ void *xpathComp; /* the compiled XPath expression */
442
+ };
443
+
444
+ /**
445
+ * xmlSchemaIDC:
446
+ *
447
+ * The identity-constraint definition component.
448
+ * (Extends xmlSchemaAnnotItem)
449
+ */
450
+
451
+ struct _xmlSchemaIDC {
452
+ xmlSchemaTypeType type;
453
+ xmlSchemaAnnotPtr annot;
454
+ xmlSchemaIDCPtr next;
455
+ xmlNodePtr node;
456
+ const xmlChar *name;
457
+ const xmlChar *targetNamespace;
458
+ xmlSchemaIDCSelectPtr selector;
459
+ xmlSchemaIDCSelectPtr fields;
460
+ int nbFields;
461
+ xmlSchemaQNameRefPtr ref;
462
+ };
463
+
464
+ /**
465
+ * xmlSchemaIDCAug:
466
+ *
467
+ * The augmented IDC information used for validation.
468
+ */
469
+ typedef struct _xmlSchemaIDCAug xmlSchemaIDCAug;
470
+ typedef xmlSchemaIDCAug *xmlSchemaIDCAugPtr;
471
+ struct _xmlSchemaIDCAug {
472
+ xmlSchemaIDCAugPtr next;
473
+ /* next in a list */
474
+ xmlSchemaIDCPtr def;
475
+ /* the IDC definition */
476
+ int keyrefDepth; /* the lowest tree level to which IDC
477
+ tables need to be bubbled upwards */
478
+ };
479
+
480
+ /**
481
+ * xmlSchemaPSVIIDCKeySequence:
482
+ *
483
+ * The key sequence of a node table item.
484
+ */
485
+ typedef struct _xmlSchemaPSVIIDCKey xmlSchemaPSVIIDCKey;
486
+ typedef xmlSchemaPSVIIDCKey *xmlSchemaPSVIIDCKeyPtr;
487
+ struct _xmlSchemaPSVIIDCKey {
488
+ xmlSchemaTypePtr type;
489
+ xmlSchemaValPtr val;
490
+ };
491
+
492
+ /**
493
+ * xmlSchemaPSVIIDCNode:
494
+ *
495
+ * The node table item of a node table.
496
+ */
497
+ typedef struct _xmlSchemaPSVIIDCNode xmlSchemaPSVIIDCNode;
498
+ typedef xmlSchemaPSVIIDCNode *xmlSchemaPSVIIDCNodePtr;
499
+ struct _xmlSchemaPSVIIDCNode {
500
+ xmlNodePtr node;
501
+ xmlSchemaPSVIIDCKeyPtr *keys;
502
+ int nodeLine;
503
+ int nodeQNameID;
504
+
505
+ };
506
+
507
+ /**
508
+ * xmlSchemaPSVIIDCBinding:
509
+ *
510
+ * The identity-constraint binding item of the [identity-constraint table].
511
+ */
512
+ typedef struct _xmlSchemaPSVIIDCBinding xmlSchemaPSVIIDCBinding;
513
+ typedef xmlSchemaPSVIIDCBinding *xmlSchemaPSVIIDCBindingPtr;
514
+ struct _xmlSchemaPSVIIDCBinding {
515
+ xmlSchemaPSVIIDCBindingPtr next;
516
+ /* next binding of a specific node */
517
+ xmlSchemaIDCPtr definition;
518
+ /* the IDC definition */
519
+ xmlSchemaPSVIIDCNodePtr *nodeTable;
520
+ /* array of key-sequences */
521
+ int nbNodes;
522
+ /* number of entries in the node table */
523
+ int sizeNodes;
524
+ /* size of the node table */
525
+ xmlSchemaItemListPtr dupls;
526
+ };
527
+
528
+
529
+ #define XPATH_STATE_OBJ_TYPE_IDC_SELECTOR 1
530
+ #define XPATH_STATE_OBJ_TYPE_IDC_FIELD 2
531
+
532
+ #define XPATH_STATE_OBJ_MATCHES -2
533
+ #define XPATH_STATE_OBJ_BLOCKED -3
534
+
535
+ typedef struct _xmlSchemaIDCMatcher xmlSchemaIDCMatcher;
536
+ typedef xmlSchemaIDCMatcher *xmlSchemaIDCMatcherPtr;
537
+
538
+ /**
539
+ * xmlSchemaIDCStateObj:
540
+ *
541
+ * The state object used to evaluate XPath expressions.
542
+ */
543
+ typedef struct _xmlSchemaIDCStateObj xmlSchemaIDCStateObj;
544
+ typedef xmlSchemaIDCStateObj *xmlSchemaIDCStateObjPtr;
545
+ struct _xmlSchemaIDCStateObj {
546
+ int type;
547
+ xmlSchemaIDCStateObjPtr next;
548
+ /* next if in a list */
549
+ int depth;
550
+ /* depth of creation */
551
+ int *history;
552
+ /* list of (depth, state-id) tuples */
553
+ int nbHistory;
554
+ int sizeHistory;
555
+ xmlSchemaIDCMatcherPtr matcher;
556
+ /* the correspondent field/selector
557
+ matcher */
558
+ xmlSchemaIDCSelectPtr sel;
559
+ void *xpathCtxt;
560
+ };
561
+
562
+ #define IDC_MATCHER 0
563
+
564
+ /**
565
+ * xmlSchemaIDCMatcher:
566
+ *
567
+ * Used to evaluate IDC selectors (and fields).
568
+ */
569
+ struct _xmlSchemaIDCMatcher {
570
+ int type;
571
+ int depth;
572
+ /* the tree depth at creation time */
573
+ xmlSchemaIDCMatcherPtr next;
574
+ /* next in the list */
575
+ xmlSchemaIDCMatcherPtr nextCached;
576
+ /* next in the cache list */
577
+ xmlSchemaIDCAugPtr aidc;
578
+ /* the augmented IDC item */
579
+ int idcType;
580
+ xmlSchemaPSVIIDCKeyPtr **keySeqs;
581
+ /* the key-sequences of the target
582
+ elements */
583
+ int sizeKeySeqs;
584
+ xmlSchemaItemListPtr targets; /* list of target-node
585
+ (xmlSchemaPSVIIDCNodePtr) entries */
586
+ };
587
+
588
+ /*
589
+ * Element info flags.
590
+ */
591
+ #define XML_SCHEMA_NODE_INFO_FLAG_OWNED_NAMES 1<<0
592
+ #define XML_SCHEMA_NODE_INFO_FLAG_OWNED_VALUES 1<<1
593
+ #define XML_SCHEMA_ELEM_INFO_NILLED 1<<2
594
+ #define XML_SCHEMA_ELEM_INFO_LOCAL_TYPE 1<<3
595
+
596
+ #define XML_SCHEMA_NODE_INFO_VALUE_NEEDED 1<<4
597
+ #define XML_SCHEMA_ELEM_INFO_EMPTY 1<<5
598
+ #define XML_SCHEMA_ELEM_INFO_HAS_CONTENT 1<<6
599
+
600
+ #define XML_SCHEMA_ELEM_INFO_HAS_ELEM_CONTENT 1<<7
601
+ #define XML_SCHEMA_ELEM_INFO_ERR_BAD_CONTENT 1<<8
602
+ #define XML_SCHEMA_NODE_INFO_ERR_NOT_EXPECTED 1<<9
603
+ #define XML_SCHEMA_NODE_INFO_ERR_BAD_TYPE 1<<10
604
+
605
+ /**
606
+ * xmlSchemaNodeInfo:
607
+ *
608
+ * Holds information of an element node.
609
+ */
610
+ struct _xmlSchemaNodeInfo {
611
+ int nodeType;
612
+ xmlNodePtr node;
613
+ int nodeLine;
614
+ const xmlChar *localName;
615
+ const xmlChar *nsName;
616
+ const xmlChar *value;
617
+ xmlSchemaValPtr val;
618
+ /* the pre-computed value if any */
619
+ xmlSchemaTypePtr typeDef;
620
+ /* the complex/simple type definition if any */
621
+
622
+ int flags;
623
+ /* combination of node info flags */
624
+
625
+ int valNeeded;
626
+ int normVal;
627
+
628
+ xmlSchemaElementPtr decl;
629
+ /* the element/attribute declaration */
630
+ int depth;
631
+ xmlSchemaPSVIIDCBindingPtr idcTable;
632
+ /* the table of PSVI IDC bindings
633
+ for the scope element*/
634
+ xmlSchemaIDCMatcherPtr idcMatchers;
635
+ /* the IDC matchers for the scope
636
+ element */
637
+ xmlRegExecCtxtPtr regexCtxt;
638
+
639
+ const xmlChar **nsBindings;
640
+ /* Namespace bindings on this element */
641
+ int nbNsBindings;
642
+ int sizeNsBindings;
643
+
644
+ int hasKeyrefs;
645
+ int appliedXPath; /* Indicates that an XPath has been applied. */
646
+ };
647
+
648
+ #define XML_SCHEMAS_ATTR_UNKNOWN 1
649
+ #define XML_SCHEMAS_ATTR_ASSESSED 2
650
+ #define XML_SCHEMAS_ATTR_PROHIBITED 3
651
+ #define XML_SCHEMAS_ATTR_ERR_MISSING 4
652
+ #define XML_SCHEMAS_ATTR_INVALID_VALUE 5
653
+ #define XML_SCHEMAS_ATTR_ERR_NO_TYPE 6
654
+ #define XML_SCHEMAS_ATTR_ERR_FIXED_VALUE 7
655
+ #define XML_SCHEMAS_ATTR_DEFAULT 8
656
+ #define XML_SCHEMAS_ATTR_VALIDATE_VALUE 9
657
+ #define XML_SCHEMAS_ATTR_ERR_WILD_STRICT_NO_DECL 10
658
+ #define XML_SCHEMAS_ATTR_HAS_ATTR_USE 11
659
+ #define XML_SCHEMAS_ATTR_HAS_ATTR_DECL 12
660
+ #define XML_SCHEMAS_ATTR_WILD_SKIP 13
661
+ #define XML_SCHEMAS_ATTR_WILD_LAX_NO_DECL 14
662
+ #define XML_SCHEMAS_ATTR_ERR_WILD_DUPLICATE_ID 15
663
+ #define XML_SCHEMAS_ATTR_ERR_WILD_AND_USE_ID 16
664
+ #define XML_SCHEMAS_ATTR_META 17
665
+ /*
666
+ * @metaType values of xmlSchemaAttrInfo.
667
+ */
668
+ #define XML_SCHEMA_ATTR_INFO_META_XSI_TYPE 1
669
+ #define XML_SCHEMA_ATTR_INFO_META_XSI_NIL 2
670
+ #define XML_SCHEMA_ATTR_INFO_META_XSI_SCHEMA_LOC 3
671
+ #define XML_SCHEMA_ATTR_INFO_META_XSI_NO_NS_SCHEMA_LOC 4
672
+ #define XML_SCHEMA_ATTR_INFO_META_XMLNS 5
673
+
674
+ typedef struct _xmlSchemaAttrInfo xmlSchemaAttrInfo;
675
+ typedef xmlSchemaAttrInfo *xmlSchemaAttrInfoPtr;
676
+ struct _xmlSchemaAttrInfo {
677
+ int nodeType;
678
+ xmlNodePtr node;
679
+ int nodeLine;
680
+ const xmlChar *localName;
681
+ const xmlChar *nsName;
682
+ const xmlChar *value;
683
+ xmlSchemaValPtr val;
684
+ /* the pre-computed value if any */
685
+ xmlSchemaTypePtr typeDef;
686
+ /* the complex/simple type definition if any */
687
+ int flags;
688
+ /* combination of node info flags */
689
+
690
+ xmlSchemaAttributePtr decl;
691
+ /* the attribute declaration */
692
+ xmlSchemaAttributeUsePtr use;
693
+ /* the attribute use */
694
+ int state;
695
+ int metaType;
696
+ const xmlChar *vcValue;
697
+ /* the value constraint value */
698
+ xmlSchemaNodeInfoPtr parent;
699
+ };
700
+
701
+
702
+ #define XML_SCHEMA_VALID_CTXT_FLAG_STREAM 1
703
+ /**
704
+ * xmlSchemaValidCtxt:
705
+ *
706
+ * A Schemas validation context
707
+ */
708
+ struct _xmlSchemaValidCtxt {
709
+ int type;
710
+ void *errCtxt;
711
+ /* user specific data block */
712
+ xmlSchemaValidityErrorFunc error;
713
+ /* the callback in case of errors */
714
+ xmlSchemaValidityWarningFunc warning;
715
+ /* the callback in case of warning */
716
+ xmlStructuredErrorFunc serror;
717
+
718
+ xmlSchemaPtr schema;
719
+ /* The schema in use */
720
+ xmlDocPtr doc;
721
+ xmlParserInputBufferPtr input;
722
+ xmlCharEncoding enc;
723
+ xmlSAXHandlerPtr sax;
724
+ xmlParserCtxtPtr parserCtxt;
725
+ void *user_data;
726
+ /* TODO: What is this for? */
727
+
728
+ int err;
729
+ int nberrors;
730
+
731
+ xmlNodePtr node;
732
+ xmlNodePtr cur;
733
+ /* xmlSchemaTypePtr type; */
734
+
735
+ xmlRegExecCtxtPtr regexp;
736
+ xmlSchemaValPtr value;
737
+
738
+ int valueWS;
739
+ int options;
740
+ xmlNodePtr validationRoot;
741
+ xmlSchemaParserCtxtPtr pctxt;
742
+ int xsiAssemble;
743
+
744
+ int depth;
745
+ xmlSchemaNodeInfoPtr *elemInfos;
746
+ /* array of element informations */
747
+ int sizeElemInfos;
748
+ xmlSchemaNodeInfoPtr inode;
749
+ /* the current element information */
750
+
751
+ xmlSchemaIDCAugPtr aidcs;
752
+ /* a list of augmented IDC informations */
753
+
754
+ xmlSchemaIDCStateObjPtr xpathStates;
755
+ /* first active state object. */
756
+ xmlSchemaIDCStateObjPtr xpathStatePool;
757
+ /* first stored state object. */
758
+ xmlSchemaIDCMatcherPtr idcMatcherCache;
759
+ /* Cache for IDC matcher objects. */
760
+
761
+ xmlSchemaPSVIIDCNodePtr *idcNodes;
762
+ /* list of all IDC node-table entries*/
763
+ int nbIdcNodes;
764
+ int sizeIdcNodes;
765
+
766
+ xmlSchemaPSVIIDCKeyPtr *idcKeys;
767
+ /* list of all IDC node-table entries */
768
+ int nbIdcKeys;
769
+ int sizeIdcKeys;
770
+
771
+ int flags;
772
+
773
+ xmlDictPtr dict;
774
+
775
+ #ifdef LIBXML_READER_ENABLED
776
+ xmlTextReaderPtr reader;
777
+ #endif
778
+
779
+ xmlSchemaAttrInfoPtr *attrInfos;
780
+ int nbAttrInfos;
781
+ int sizeAttrInfos;
782
+
783
+ int skipDepth;
784
+ xmlSchemaItemListPtr nodeQNames;
785
+ int hasKeyrefs;
786
+ int createIDCNodeTables;
787
+ int psviExposeIDCNodeTables;
788
+ };
789
+
790
+ /**
791
+ * xmlSchemaSubstGroup:
792
+ *
793
+ *
794
+ */
795
+ typedef struct _xmlSchemaSubstGroup xmlSchemaSubstGroup;
796
+ typedef xmlSchemaSubstGroup *xmlSchemaSubstGroupPtr;
797
+ struct _xmlSchemaSubstGroup {
798
+ xmlSchemaElementPtr head;
799
+ xmlSchemaItemListPtr members;
800
+ };
801
+
802
+ /*static xmlSchemaQNameRefPtr
803
+ xmlSchemaParseAttributeGroupRef(xmlSchemaParserCtxtPtr pctxt,
804
+ xmlSchemaPtr schema,
805
+ xmlNodePtr node);*/
806
+
807
+
10
808
  #endif
11
809