ntdll: Use the getdents64 system call on all Linux platforms.
[wine] / dlls / msxml3 / xdr.c
1 /*
2  * XDR (XML-Data Reduced) -> XSD (XML Schema Document) conversion
3  *
4  * Copyright 2010 Adam Martinson for CodeWeavers
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21
22 #include "config.h"
23 #include "wine/debug.h"
24 #include <assert.h>
25
26 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
27
28 /* Both XDR and XSD are valid XML
29  * We just convert the doc tree, no need for a parser.
30  */
31
32 #ifdef HAVE_LIBXML2
33
34 #include <libxml/tree.h>
35
36 static const xmlChar DT_prefix[] = "dt";
37 static const xmlChar DT_href[] = "urn:schemas-microsoft-com:datatypes";
38 static const xmlChar XDR_prefix[] = "xdr";
39 static const xmlChar XDR_href[] = "urn:schemas-microsoft-com:xml-data";
40 static const xmlChar XSD_prefix[] = "xsd";
41 static const xmlChar XSD_href[] = "http://www.w3.org/2001/XMLSchema";
42
43 static const xmlChar xs_all[] = "all";
44 static const xmlChar xs_annotation[] = "annotation";
45 static const xmlChar xs_any[] = "any";
46 static const xmlChar xs_anyAttribute[] = "anyAttribute";
47 static const xmlChar xs_attribute[] = "attribute";
48 static const xmlChar xs_AttributeType[] = "AttributeType";
49 static const xmlChar xs_base[] = "base";
50 static const xmlChar xs_choice[] = "choice";
51 static const xmlChar xs_complexContent[] = "complexContent";
52 static const xmlChar xs_complexType[] = "complexType";
53 static const xmlChar xs_content[] = "content";
54 static const xmlChar xs_datatype[] = "datatype";
55 static const xmlChar xs_default[] = "default";
56 static const xmlChar xs_description[] = "description";
57 static const xmlChar xs_documentation[] = "documentation";
58 static const xmlChar xs_element[] = "element";
59 static const xmlChar xs_ElementType[] = "ElementType";
60 static const xmlChar xs_eltOnly[] = "eltOnly";
61 static const xmlChar xs_empty[] = "empty";
62 static const xmlChar xs_enumeration[] = "enumeration";
63 static const xmlChar xs_extension[] = "extension";
64 static const xmlChar xs_group[] = "group";
65 static const xmlChar xs_lax[] = "lax";
66 static const xmlChar xs_length[] = "length";
67 static const xmlChar xs_many[] = "many";
68 static const xmlChar xs_maxOccurs[] = "maxOccurs";
69 static const xmlChar xs_minOccurs[] = "minOccurs";
70 static const xmlChar xs_mixed[] = "mixed";
71 static const xmlChar xs_model[] = "model";
72 static const xmlChar xs_name[] = "name";
73 static const xmlChar xs_namespace[] = "namespace";
74 static const xmlChar xs_no[] = "no";
75 static const xmlChar xs_one[] = "one";
76 static const xmlChar xs_open[] = "open";
77 static const xmlChar xs_optional[] = "optional";
78 static const xmlChar xs_order[] = "order";
79 static const xmlChar xs_processContents[] = "processContents";
80 static const xmlChar xs_ref[] = "ref";
81 static const xmlChar xs_required[] = "required";
82 static const xmlChar xs_restriction[] = "restriction";
83 static const xmlChar xs_schema[] = "schema";
84 static const xmlChar xs_Schema[] = "Schema";
85 static const xmlChar xs_seq[] = "seq";
86 static const xmlChar xs_sequence[] = "sequence";
87 static const xmlChar xs_simpleContent[] = "simpleContent";
88 static const xmlChar xs_simpleType[] = "simpleType";
89 static const xmlChar xs_strict[] = "strict";
90 static const xmlChar xs_targetNamespace[] = "targetNamespace";
91 static const xmlChar xs_textOnly[] = "textOnly";
92 static const xmlChar xs_true[] = "true";
93 static const xmlChar xs_type[] = "type";
94 static const xmlChar xs_unbounded[] = "unbounded";
95 static const xmlChar xs_use[] = "use";
96 static const xmlChar xs_value[] = "value";
97 static const xmlChar xs_values[] = "values";
98 static const xmlChar xs_xsd_string[] = "xsd:string";
99 static const xmlChar xs_yes[] = "yes";
100
101 typedef enum _CONTENT_TYPE
102 {
103     CONTENT_EMPTY,
104     CONTENT_TEXTONLY,
105     CONTENT_ELTONLY,
106     CONTENT_MIXED
107 } CONTENT_TYPE;
108
109 typedef enum _ORDER_TYPE
110 {
111     ORDER_SEQ,
112     ORDER_MANY,
113     ORDER_ONE
114 } ORDER_TYPE;
115
116 #define FOREACH_CHILD(node, child) \
117     for (child = node->children; child != NULL; child = child->next) \
118         if (child->type == XML_ELEMENT_NODE)
119
120 #define FOREACH_ATTR(node, attr) \
121     for (attr = node->properties; attr != NULL; attr = attr->next)
122
123 #define FOREACH_NS(node, ns) \
124     for (ns = node->nsDef; ns != NULL; ns = ns->next)
125
126 static inline xmlNodePtr get_schema(xmlNodePtr node)
127 {
128     return xmlDocGetRootElement(node->doc);
129 }
130
131 static inline xmlNodePtr get_child(xmlNodePtr node, xmlChar const* name)
132 {
133     xmlNodePtr child = NULL;
134     if (node)
135     {
136         FOREACH_CHILD(node, child)
137         {
138             if (xmlStrEqual(child->name, name))
139                 break;
140         }
141     }
142
143     return child;
144 }
145
146 static inline xmlNodePtr get_child_with_attr(xmlNodePtr node, xmlChar const* name,
147                                              xmlChar const* attr_ns, xmlChar const* attr_name,
148                                              xmlChar const* attr_val)
149 {
150     xmlChar* str;
151     if (node)
152     {
153         FOREACH_CHILD(node, node)
154         {
155             if (xmlStrEqual(node->name, name))
156             {
157                 str = (attr_ns != NULL)? xmlGetNsProp(node, attr_name, attr_ns) :
158                                                   xmlGetProp(node, attr_name);
159                 if (str)
160                 {
161                     if (xmlStrEqual(str, attr_val))
162                     {
163                         xmlFree(str);
164                         return node;
165                     }
166                     xmlFree(str);
167                 }
168             }
169         }
170     }
171
172     return NULL;
173 }
174
175 static inline xmlNsPtr get_dt_ns(xmlNodePtr node)
176 {
177     xmlNsPtr ns;
178
179     node = get_schema(node);
180     assert(node != NULL);
181
182     FOREACH_NS(node, ns)
183     {
184         if (xmlStrEqual(ns->href, DT_href))
185             break;
186     }
187
188     return ns;
189 }
190
191 static inline xmlChar* get_dt_type(xmlNodePtr xdr)
192 {
193     xmlChar* str = xmlGetNsProp(xdr, xs_type, DT_href);
194     if (!str)
195     {
196         xmlNodePtr datatype = get_child(xdr, xs_datatype);
197         if (datatype)
198             str = xmlGetNsProp(datatype, xs_type, DT_href);
199     }
200     return str;
201 }
202
203 static inline xmlChar* get_attr_val(xmlAttrPtr attr)
204 {
205     return xmlNodeGetContent((xmlNodePtr)attr);
206 }
207
208 static inline xmlNodePtr add_any_child(xmlNodePtr parent, BOOL set_occurs)
209 {
210     xmlNodePtr child = xmlNewChild(parent, NULL, xs_any, NULL);
211     if (set_occurs)
212     {
213         xmlSetProp(child, xs_minOccurs, BAD_CAST "0");
214         xmlSetProp(child, xs_maxOccurs, xs_unbounded);
215     }
216     xmlSetProp(child, xs_processContents, xs_strict);
217     return child;
218 }
219
220 static inline xmlNodePtr add_anyAttribute_child(xmlNodePtr parent)
221 {
222     xmlNodePtr child = xmlNewChild(parent, NULL, xs_anyAttribute, NULL);
223     xmlSetProp(child, xs_processContents, xs_lax);
224     return child;
225 }
226
227 static inline xmlAttrPtr copy_prop_ignore_ns(xmlAttrPtr xdr_attr, xmlNodePtr node)
228 {
229     xmlChar* str = get_attr_val(xdr_attr);
230     xmlAttrPtr attr = xmlSetProp(node, xdr_attr->name, str);
231     xmlFree(str);
232     return attr;
233 }
234 static inline xmlAttrPtr XDR_A_default(xmlAttrPtr xdr_attr, xmlNodePtr node)
235 {
236     TRACE("(%p, %p)\n", xdr_attr, node);
237
238     return copy_prop_ignore_ns(xdr_attr, node);
239 }
240
241 static inline xmlAttrPtr XDR_A_dt_type(xmlAttrPtr xdr_attr, xmlNodePtr node)
242 {
243     xmlChar* str = get_attr_val(xdr_attr);
244     xmlAttrPtr attr;
245
246     TRACE("(%p, %p)\n", xdr_attr, node);
247
248     if (xmlStrEqual(str, xs_enumeration))
249         attr = NULL;
250     else
251         attr = xmlSetNsProp(node, get_dt_ns(node), DT_prefix, str);
252     xmlFree(str);
253     return attr;
254 }
255
256 static xmlAttrPtr XDR_A_maxOccurs(xmlAttrPtr xdr_attr, xmlNodePtr node)
257 {
258     xmlChar* str = get_attr_val(xdr_attr);
259     xmlAttrPtr attr;
260
261     TRACE("(%p, %p)\n", xdr_attr, node);
262
263     if (xmlStrEqual(str, BAD_CAST "*"))
264         attr = xmlSetProp(node, xs_maxOccurs, xs_unbounded);
265     else
266         attr = copy_prop_ignore_ns(xdr_attr, node);
267
268     xmlFree(str);
269     return attr;
270 }
271
272 static inline xmlAttrPtr XDR_A_minOccurs(xmlAttrPtr xdr_attr, xmlNodePtr node)
273 {
274     TRACE("(%p, %p)\n", xdr_attr, node);
275
276     return copy_prop_ignore_ns(xdr_attr, node);
277 }
278
279 static inline xmlAttrPtr XDR_A_name(xmlAttrPtr xdr_attr, xmlNodePtr node)
280 {
281     TRACE("(%p, %p)\n", xdr_attr, node);
282
283     return copy_prop_ignore_ns(xdr_attr, node);
284 }
285
286 static xmlAttrPtr XDR_A_type(xmlAttrPtr xdr_attr, xmlNodePtr node)
287 {
288     xmlChar* str = get_attr_val(xdr_attr);
289     xmlAttrPtr attr = xmlSetProp(node, xs_ref, str);
290
291     TRACE("(%p, %p)\n", xdr_attr, node);
292
293     xmlFree(str);
294     return attr;
295 }
296
297 static xmlAttrPtr XDR_A_required(xmlAttrPtr xdr_attr, xmlNodePtr node)
298 {
299     xmlChar* str = get_attr_val(xdr_attr);
300     xmlAttrPtr attr;
301
302     TRACE("(%p, %p)\n", xdr_attr, node);
303
304     if (xmlStrEqual(str, xs_no))
305         attr = xmlSetProp(node, xs_use, xs_optional);
306     else /* yes */
307         attr = xmlSetProp(node, xs_use, xs_required);
308     xmlFree(str);
309     return attr;
310 }
311
312 static xmlNodePtr XDR_E_description(xmlNodePtr xdr, xmlNodePtr parent)
313 {
314     xmlNodePtr xsd_node = xmlNewChild(parent, NULL, xs_annotation, NULL);
315     xmlAttrPtr xdr_attr;
316
317     TRACE("(%p, %p)\n", xdr, parent);
318
319     xmlNewChild(xsd_node, NULL, xs_documentation, xdr->content);
320
321     FOREACH_ATTR(xdr, xdr_attr)
322     {
323         xmlCopyProp(xsd_node, xdr_attr);
324     }
325     return xsd_node;
326 }
327
328 static xmlNodePtr XDR_E_AttributeType(xmlNodePtr xdr, xmlNodePtr parent)
329 {
330     xmlChar *str, *type = get_dt_type(xdr);
331     xmlNodePtr xsd_node, xsd_child, xdr_child;
332     xmlAttrPtr xdr_attr;
333
334     TRACE("(%p, %p)\n", xdr, parent);
335
336     xsd_node = xmlNewChild(parent, NULL, xs_attribute, NULL);
337
338     if (type && xmlStrEqual(type, xs_enumeration))
339     {
340         xmlChar *tmp, *tokBegin, *tokEnd = NULL;
341         xmlNodePtr xsd_enum;
342         xsd_child = xmlNewChild(xsd_node, NULL, xs_simpleType, NULL);
343         xsd_child = xmlNewChild(xsd_child, NULL, xs_restriction, NULL);
344         xmlSetProp(xsd_child, xs_base, xs_xsd_string);
345
346         tokBegin = str = xmlGetNsProp(xdr, xs_values, DT_href);
347         while (tokBegin && *tokBegin)
348         {
349             while (*tokBegin && isspace(*tokBegin))
350                 ++tokBegin;
351             tokEnd = tokBegin;
352             while (*tokEnd && !isspace(*tokEnd))
353                 ++tokEnd;
354             if (tokEnd == tokBegin)
355                 break;
356             xsd_enum = xmlNewChild(xsd_child, NULL, xs_enumeration, NULL);
357             tmp = xmlStrndup(tokBegin, tokEnd-tokBegin);
358             xmlSetProp(xsd_enum, xs_value, tmp);
359             xmlFree(tmp);
360             tokBegin = tokEnd;
361         }
362         xmlFree(str);
363
364     }
365     else if (type)
366     {
367         str = xmlStrdup(DT_prefix);
368         str = xmlStrcat(str, BAD_CAST ":");
369         str = xmlStrcat(str, type);
370         xmlSetProp(xsd_node, xs_type, str);
371         xmlFree(str);
372     }
373     xmlFree(type);
374
375     FOREACH_ATTR(xdr, xdr_attr)
376     {
377         if (xmlStrEqual(xdr_attr->name, xs_default))
378             XDR_A_default(xdr_attr, xsd_node);
379         else if (xmlStrEqual(xdr_attr->name, xs_name))
380             XDR_A_name(xdr_attr, xsd_node);
381         else if (xmlStrEqual(xdr_attr->name, xs_type) && xdr_attr->ns == get_dt_ns(xdr))
382             XDR_A_dt_type(xdr_attr, xsd_node);
383         else if (xmlStrEqual(xdr_attr->name, xs_values) && xdr_attr->ns == get_dt_ns(xdr))
384             ; /* already handled */
385         else if (xmlStrEqual(xdr_attr->name, xs_required))
386             XDR_A_required(xdr_attr, xsd_node);
387         else
388             xmlCopyProp(xsd_node, xdr_attr);
389     }
390
391     FOREACH_CHILD(xdr, xdr_child)
392     {
393         if (xmlStrEqual(xdr_child->name, xs_datatype))
394             ; /* already handled */
395         else if (xmlStrEqual(xdr_child->name, xs_description))
396             XDR_E_description(xdr_child, xsd_node);
397         else
398             FIXME("unexpected child <%s>\n", xdr_child->name);
399     }
400
401     return xsd_node;
402 }
403
404 static xmlNodePtr XDR_E_attribute(xmlNodePtr xdr, xmlNodePtr parent)
405 {
406     xmlChar* str = xmlGetProp(xdr, xs_type);
407     xmlNodePtr xsd_node, xdr_child, xdr_attrType;
408     xmlAttrPtr xdr_attr;
409
410     TRACE("(%p, %p)\n", xdr, parent);
411
412     xdr_attrType = get_child_with_attr(xdr->parent, xs_AttributeType, NULL, xs_name, str);
413     xmlFree(str);
414
415     if (xdr_attrType)
416         xsd_node = XDR_E_AttributeType(xdr_attrType, parent);
417     else
418         xsd_node = xmlNewChild(parent, NULL, xs_attribute, NULL);
419
420     FOREACH_ATTR(xdr, xdr_attr)
421     {
422         if (xmlStrEqual(xdr_attr->name, xs_default))
423             XDR_A_default(xdr_attr, xsd_node);
424         else if (xmlStrEqual(xdr_attr->name, xs_type) && !xdr_attrType)
425             XDR_A_type(xdr_attr, xsd_node);
426         else if (xmlStrEqual(xdr_attr->name, xs_required))
427             XDR_A_required(xdr_attr, xsd_node);
428         else
429             xmlCopyProp(xsd_node, xdr_attr);
430     }
431
432     FOREACH_CHILD(xdr, xdr_child)
433     {
434         FIXME("unexpected child <%s>\n", xdr_child->name);
435     }
436
437     return xsd_node;
438 }
439
440 static xmlNodePtr XDR_E_element(xmlNodePtr xdr, xmlNodePtr parent)
441 {
442     xmlNodePtr xdr_child, xsd_node = xmlNewChild(parent, NULL, xs_element, NULL);
443     xmlAttrPtr xdr_attr;
444
445     FOREACH_ATTR(xdr, xdr_attr)
446     {
447         if (xmlStrEqual(xdr_attr->name, xs_type))
448             XDR_A_type(xdr_attr, xsd_node);
449         else if (xmlStrEqual(xdr_attr->name, xs_maxOccurs))
450             XDR_A_maxOccurs(xdr_attr, xsd_node);
451         else if (xmlStrEqual(xdr_attr->name, xs_minOccurs))
452             XDR_A_minOccurs(xdr_attr, xsd_node);
453         else
454             xmlCopyProp(xsd_node, xdr_attr);
455     }
456
457     FOREACH_CHILD(xdr, xdr_child)
458     {
459         FIXME("unexpected child <%s>\n", xdr_child->name);
460     }
461
462     return xsd_node;
463 }
464
465 static xmlNodePtr XDR_E_group(xmlNodePtr xdr, xmlNodePtr parent)
466 {
467     xmlNodePtr xdr_child, xsd_node;
468     xmlChar* str = xmlGetProp(xdr, xs_order);
469     xmlAttrPtr xdr_attr;
470
471     TRACE("(%p, %p)\n", xdr, parent);
472
473     if (!str || xmlStrEqual(str, xs_seq))
474         xsd_node = xmlNewChild(parent, NULL, xs_sequence, NULL);
475     else if (xmlStrEqual(str, xs_many))
476         xsd_node = xmlNewChild(parent, NULL, xs_choice, NULL);
477     else /* one */
478         xsd_node = xmlNewChild(parent, NULL, xs_all, NULL);
479     xmlFree(str);
480
481     FOREACH_ATTR(xdr, xdr_attr)
482     {
483         if (xmlStrEqual(xdr_attr->name, xs_order))
484             ; /* already handled */
485         else if (xmlStrEqual(xdr_attr->name, xs_model))
486             ; /* ignored */
487         else if (xmlStrEqual(xdr_attr->name, xs_maxOccurs))
488             XDR_A_maxOccurs(xdr_attr, xsd_node);
489         else if (xmlStrEqual(xdr_attr->name, xs_minOccurs))
490             XDR_A_minOccurs(xdr_attr, xsd_node);
491         else
492             xmlCopyProp(xsd_node, xdr_attr);
493     }
494
495     FOREACH_CHILD(xdr, xdr_child)
496     {
497         if (xmlStrEqual(xdr_child->name, xs_description))
498             XDR_E_description(xdr_child, xsd_node);
499         else if (xmlStrEqual(xdr_child->name, xs_element))
500             XDR_E_element(xdr_child, xsd_node);
501     }
502
503     return xsd_node;
504 }
505
506 static xmlNodePtr XDR_E_ElementType(xmlNodePtr xdr, xmlNodePtr parent)
507 {
508     xmlChar *str, *type = get_dt_type(xdr);
509     BOOL is_open = TRUE;
510     int n_attributes = 0, n_elements = 0, n_groups = 0;
511     CONTENT_TYPE content;
512     ORDER_TYPE order;
513     xmlNodePtr xsd_node, xsd_type, xsd_child, xdr_child;
514     xmlAttrPtr xdr_attr;
515     xmlNsPtr dt_ns = get_dt_ns(parent);
516
517     TRACE("(%p, %p)\n", xdr, parent);
518
519     str = xmlGetProp(xdr, xs_model);
520     if (str && !xmlStrEqual(str, xs_open))
521         is_open = FALSE;
522     xmlFree(str);
523
524     if (type)
525     {
526         content = CONTENT_TEXTONLY;
527     }
528     else
529     {
530         str = xmlGetProp(xdr, xs_content);
531         if (!str || xmlStrEqual(str, xs_mixed))
532             content = CONTENT_MIXED;
533         else if (xmlStrEqual(str, xs_eltOnly))
534             content = CONTENT_ELTONLY;
535         else if (xmlStrEqual(str, xs_textOnly))
536             content = CONTENT_TEXTONLY;
537         else /* empty */
538             content = CONTENT_EMPTY;
539         xmlFree(str);
540     }
541
542     str = xmlGetProp(xdr, xs_order);
543     if (!str || xmlStrEqual(str, xs_seq))
544     {
545         order = ORDER_SEQ;
546     }
547     else if (xmlStrEqual(str, xs_many))
548     {
549         order = ORDER_MANY;
550     }
551     else /* one */
552     {
553         order = ORDER_ONE;
554         is_open = FALSE;
555     }
556     xmlFree(str);
557
558     FOREACH_CHILD(xdr, xdr_child)
559     {
560         if (xmlStrEqual(xdr_child->name, xs_element))
561             ++n_elements;
562         else if (xmlStrEqual(xdr_child->name, xs_group))
563             ++n_groups;
564         else if (xmlStrEqual(xdr_child->name, xs_attribute))
565             ++n_attributes;
566     }
567
568     xsd_node = xmlNewChild(parent, NULL, xs_element, NULL);
569     assert(xsd_node != NULL);
570     switch (content)
571     {
572         case CONTENT_MIXED:
573         case CONTENT_ELTONLY:
574             {
575                 xmlNodePtr xsd_base;
576                 xsd_type = xmlNewChild(xsd_node, NULL, xs_complexType, NULL);
577
578                 if (content == CONTENT_MIXED)
579                     xmlSetProp(xsd_type, xs_mixed, xs_true);
580
581                 if (is_open)
582                     xsd_base = xmlNewChild(xsd_type, NULL, xs_sequence, NULL);
583                 else
584                     xsd_base = xsd_type;
585
586                 if (is_open && n_elements < 2 && !n_groups)
587                 {/* no specific sequence of elements we need,
588                     just has to start with the right one, if any */
589                     if ((xdr_child = get_child(xdr, xs_element)))
590                     {
591                         xsd_child = XDR_E_element(xdr_child, xsd_base);
592                         xmlUnsetProp(xsd_child, xs_maxOccurs);
593                     }
594                 }
595                 else
596                 {
597                     switch (order)
598                     {
599                         case ORDER_SEQ:
600                             xsd_child = xmlNewChild(xsd_base, NULL, xs_sequence, NULL);
601                             break;
602                         case ORDER_MANY:
603                             xsd_child = xmlNewChild(xsd_base, NULL, xs_choice, NULL);
604                             xmlSetProp(xsd_child, xs_maxOccurs, xs_unbounded);
605                             break;
606                         case ORDER_ONE:
607                             xsd_child = xmlNewChild(xsd_base, NULL, xs_all, NULL);
608                             break;
609                     }
610
611                     FOREACH_CHILD(xdr, xdr_child)
612                     {
613                         if (xmlStrEqual(xdr_child->name, xs_element))
614                             XDR_E_element(xdr_child, xsd_child);
615                         else if (xmlStrEqual(xdr_child->name, xs_group))
616                             XDR_E_group(xdr_child, xsd_child);
617                     }
618                 }
619
620                 if (n_attributes)
621                 {
622                     FOREACH_CHILD(xdr, xdr_child)
623                     {
624                         if (xmlStrEqual(xdr_child->name, xs_attribute))
625                             XDR_E_attribute(xdr_child, xsd_type);
626                     }
627                 }
628
629                 if (is_open)
630                 {
631                     add_any_child(xsd_base, TRUE);
632                     add_anyAttribute_child(xsd_type);
633                 }
634             }
635             break;
636         case CONTENT_TEXTONLY:
637             {
638                 if (is_open)
639                 {
640                     xsd_type = xmlNewChild(xsd_node, NULL, xs_complexType, NULL);
641                     if (type)
642                     {
643                         xsd_child = xmlNewChild(xsd_type, NULL, xs_simpleContent, NULL);
644                         xsd_child = xmlNewChild(xsd_child, NULL, xs_extension, NULL);
645                         str = xmlStrdup(DT_prefix);
646                         str = xmlStrcat(str, BAD_CAST ":");
647                         str = xmlStrcat(str, type);
648                         xmlSetProp(xsd_child, xs_base, str);
649                         xmlFree(str);
650                         assert(dt_ns != NULL);
651                         xmlSetNsProp(xsd_node, dt_ns, DT_prefix, type);
652                     }
653                     else
654                     {
655                         xmlSetProp(xsd_type, xs_mixed, xs_true);
656                         xsd_child = xmlNewChild(xsd_type, NULL, xs_choice, NULL);
657                         xmlSetProp(xsd_child, xs_minOccurs, BAD_CAST "0");
658                         xmlSetProp(xsd_child, xs_maxOccurs, xs_unbounded);
659                         xsd_child = add_any_child(xsd_child, FALSE);
660                         xmlSetProp(xsd_child, xs_namespace, BAD_CAST "##other");
661                         xsd_child = xsd_type;
662                     }
663
664                     if (n_attributes)
665                         FOREACH_CHILD(xdr, xdr_child)
666                         {
667                             if (xmlStrEqual(xdr_child->name, xs_attribute))
668                                 XDR_E_attribute(xdr_child, xsd_child);
669                         }
670
671                     xmlNewChild(xsd_child, NULL, xs_anyAttribute, NULL);
672                 }
673                 else if (!n_attributes)
674                 {
675                     if (type)
676                     {
677                         str = xmlStrdup(DT_prefix);
678                         str = xmlStrcat(str, BAD_CAST ":");
679                         str = xmlStrcat(str, type);
680                         xmlSetProp(xsd_node, xs_type, str);
681                         xmlFree(str);
682                         str = NULL;
683                         xmlSetNsProp(xsd_node, dt_ns, DT_prefix, type);
684                     }
685                     else
686                     {
687                         xmlSetProp(xsd_node, xs_type, xs_xsd_string);
688                     }
689                 }
690                 else
691                 {
692                     xsd_type = xmlNewChild(xsd_node, NULL, xs_complexType, NULL);
693                     xsd_child = xmlNewChild(xsd_type, NULL, xs_simpleContent, NULL);
694                     xsd_child = xmlNewChild(xsd_child, NULL, xs_extension, NULL);
695                     xmlSetProp(xsd_child, xs_base, xs_xsd_string);
696
697                     FOREACH_CHILD(xdr, xdr_child)
698                     {
699                         if (xmlStrEqual(xdr_child->name, xs_attribute))
700                             XDR_E_attribute(xdr_child, xsd_child);
701                     }
702                 }
703             }
704             break;
705         case CONTENT_EMPTY: /* not allowed with model="open" */
706             {
707                 if (n_attributes)
708                 {
709                     xsd_type = xmlNewChild(xsd_node, NULL, xs_complexType, NULL);
710
711                     FOREACH_CHILD(xdr, xdr_child)
712                     {
713                         if (xmlStrEqual(xdr_child->name, xs_attribute))
714                             XDR_E_attribute(xdr_child, xsd_type);
715                     }
716                 }
717                 else
718                 {
719                     xsd_type = xmlNewChild(xsd_node, NULL, xs_simpleType, NULL);
720                     xsd_child = xmlNewChild(xsd_type, NULL, xs_restriction, NULL);
721                     xmlSetProp(xsd_child, xs_base, xs_xsd_string);
722                     xsd_child = xmlNewChild(xsd_child, NULL, xs_length, NULL);
723                     xmlSetProp(xsd_child, xs_value, BAD_CAST "0");
724                 }
725             }
726             break;
727     }
728     xmlFree(type);
729
730     FOREACH_ATTR(xdr, xdr_attr)
731     {
732         if (xmlStrEqual(xdr_attr->name, xs_content))
733             ; /* already handled */
734         else if (xmlStrEqual(xdr_attr->name, xs_name))
735             XDR_A_name(xdr_attr, xsd_node);
736         else if (xmlStrEqual(xdr_attr->name, xs_type) && xdr_attr->ns == get_dt_ns(xdr))
737             XDR_A_dt_type(xdr_attr, xsd_node);
738         else if (xmlStrEqual(xdr_attr->name, xs_model))
739             ; /* already handled */
740         else if (xmlStrEqual(xdr_attr->name, xs_order))
741             ; /* already handled */
742         else
743             xmlCopyProp(xsd_node, xdr_attr);
744
745     }
746
747     FOREACH_CHILD(xdr, xdr_child)
748     {
749         if (xmlStrEqual(xdr_child->name, xs_attribute))
750             ; /* already handled */
751         else if (xmlStrEqual(xdr_child->name, xs_AttributeType))
752             ; /* handled through XDR_E_attribute when parent is not <Schema> */
753         else if (xmlStrEqual(xdr_child->name, xs_datatype))
754             ; /* already handled */
755         else if (xmlStrEqual(xdr_child->name, xs_description))
756             XDR_E_description(xdr_child, xsd_node);
757         else if (xmlStrEqual(xdr_child->name, xs_element))
758             ; /* already handled */
759         else if (xmlStrEqual(xdr_child->name, xs_group))
760             ; /* already handled */
761         else
762             FIXME("unexpected child <%s>\n", xdr_child->name);
763     }
764
765     return xsd_node;
766 }
767
768 static xmlNodePtr XDR_E_Schema(xmlNodePtr xdr, xmlNodePtr parent, xmlChar const* nsURI)
769 {
770     xmlNodePtr xsd_node, xdr_child;
771     xmlNsPtr ns, xdr_ns;
772     xmlAttrPtr xdr_attr;
773
774     TRACE("(%p, %p)\n", xdr, parent);
775
776     xsd_node = xmlNewDocNode((xmlDocPtr)parent, NULL, xs_schema, NULL);
777     xmlDocSetRootElement((xmlDocPtr)parent, xsd_node);
778     assert(xsd_node != NULL);
779
780     if (nsURI && *nsURI) xmlNewNs(xsd_node, nsURI, NULL);
781     ns = xmlNewNs(xsd_node, XSD_href, XSD_prefix);
782     assert(ns != NULL);
783
784     xmlSetNs(xsd_node, ns);
785
786     if (nsURI && *nsURI) xmlSetProp(xsd_node, xs_targetNamespace, nsURI);
787
788     FOREACH_NS(xdr, xdr_ns)
789     {
790         /* TODO: special handling for dt namespace? */
791         assert(xdr_ns->href != NULL);
792         if (xmlStrEqual(xdr_ns->href, XDR_href))
793             ; /* ignored */
794         else if (xdr_ns->prefix != NULL)
795             xmlNewNs(xsd_node, xdr_ns->href, xdr_ns->prefix);
796         else
797             FIXME("unexpected default xmlns: %s\n", xdr_ns->href);
798     }
799
800     FOREACH_ATTR(xdr, xdr_attr)
801     {
802         xmlCopyProp(xsd_node, xdr_attr);
803     }
804
805     FOREACH_CHILD(xdr, xdr_child)
806     {
807         if (xmlStrEqual(xdr_child->name, xs_AttributeType))
808             XDR_E_AttributeType(xdr_child, xsd_node);
809         else if (xmlStrEqual(xdr_child->name, xs_description))
810             XDR_E_description(xdr_child, xsd_node);
811         else if (xmlStrEqual(xdr_child->name, xs_ElementType))
812             XDR_E_ElementType(xdr_child, xsd_node);
813         else
814             FIXME("unexpected child <%s>\n", xdr_child->name);
815     }
816
817     return xsd_node;
818 }
819
820 xmlDocPtr XDR_to_XSD_doc(xmlDocPtr xdr_doc, xmlChar const* nsURI)
821 {
822     xmlDocPtr xsd_doc = xmlNewDoc(NULL);
823
824     TRACE("(%p)\n", xdr_doc);
825
826     XDR_E_Schema(get_schema((xmlNodePtr)xdr_doc), (xmlNodePtr)xsd_doc, nsURI);
827
828     return xsd_doc;
829 }
830
831 #endif /* HAVE_LIBXML2 */