xdr.c File Reference

#include <assert.h>
#include <libxml/tree.h>
#include "wine/debug.h"

Include dependency graph for xdr.c:

Go to the source code of this file.

Macros
#define	FOREACH_CHILD(node, child)
#define	FOREACH_ATTR(node, attr)    for (attr = node->properties; attr != NULL; attr = attr->next)
#define	FOREACH_NS(node, ns)    for (ns = node->nsDef; ns != NULL; ns = ns->next)

Typedefs
typedef enum _CONTENT_TYPE	CONTENT_TYPE
typedef enum _ORDER_TYPE	ORDER_TYPE

Enumerations
enum	_CONTENT_TYPE { CONTENT_EMPTY , CONTENT_TEXTONLY , CONTENT_ELTONLY , CONTENT_MIXED }
enum	_ORDER_TYPE { ORDER_SEQ , ORDER_MANY , ORDER_ONE }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (msxml)
static xmlNodePtr	get_schema (xmlNodePtr node)
static xmlNodePtr	get_child (xmlNodePtr node, xmlChar const *name)
static xmlNodePtr	get_child_with_attr (xmlNodePtr node, xmlChar const *name, xmlChar const *attr_ns, xmlChar const *attr_name, xmlChar const *attr_val)
static xmlNsPtr	get_dt_ns (xmlNodePtr node)
static xmlChar *	get_dt_type (xmlNodePtr xdr)
static xmlChar *	get_attr_val (xmlAttrPtr attr)
static xmlNodePtr	add_any_child (xmlNodePtr parent, BOOL set_occurs)
static xmlNodePtr	add_anyAttribute_child (xmlNodePtr parent)
static xmlAttrPtr	copy_prop_ignore_ns (xmlAttrPtr xdr_attr, xmlNodePtr node)
static xmlAttrPtr	XDR_A_default (xmlAttrPtr xdr_attr, xmlNodePtr node)
static xmlAttrPtr	XDR_A_dt_type (xmlAttrPtr xdr_attr, xmlNodePtr node)
static xmlAttrPtr	XDR_A_maxOccurs (xmlAttrPtr xdr_attr, xmlNodePtr node)
static xmlAttrPtr	XDR_A_minOccurs (xmlAttrPtr xdr_attr, xmlNodePtr node)
static xmlAttrPtr	XDR_A_name (xmlAttrPtr xdr_attr, xmlNodePtr node)
static xmlAttrPtr	XDR_A_type (xmlAttrPtr xdr_attr, xmlNodePtr node)
static xmlAttrPtr	XDR_A_required (xmlAttrPtr xdr_attr, xmlNodePtr node)
static xmlNodePtr	XDR_E_description (xmlNodePtr xdr, xmlNodePtr parent)
static xmlNodePtr	XDR_E_AttributeType (xmlNodePtr xdr, xmlNodePtr parent)
static xmlNodePtr	XDR_E_attribute (xmlNodePtr xdr, xmlNodePtr parent)
static xmlNodePtr	XDR_E_element (xmlNodePtr xdr, xmlNodePtr parent)
static xmlNodePtr	XDR_E_group (xmlNodePtr xdr, xmlNodePtr parent)
static xmlNodePtr	XDR_E_ElementType (xmlNodePtr xdr, xmlNodePtr parent)
static xmlNodePtr	XDR_E_Schema (xmlNodePtr xdr, xmlNodePtr parent, xmlChar const *nsURI)
xmlDocPtr	XDR_to_XSD_doc (xmlDocPtr xdr_doc, xmlChar const *nsURI)

Variables
static const xmlChar	DT_prefix [] = "dt"
static const xmlChar	DT_href [] = "urn:schemas-microsoft-com:datatypes"
static const xmlChar	XDR_href [] = "urn:schemas-microsoft-com:xml-data"
static const xmlChar	XSD_prefix [] = "xsd"
static const xmlChar	XSD_href [] = "http://www.w3.org/2001/XMLSchema"
static const xmlChar	xs_all [] = "all"
static const xmlChar	xs_annotation [] = "annotation"
static const xmlChar	xs_any [] = "any"
static const xmlChar	xs_anyAttribute [] = "anyAttribute"
static const xmlChar	xs_attribute [] = "attribute"
static const xmlChar	xs_AttributeType [] = "AttributeType"
static const xmlChar	xs_base [] = "base"
static const xmlChar	xs_choice [] = "choice"
static const xmlChar	xs_complexType [] = "complexType"
static const xmlChar	xs_content [] = "content"
static const xmlChar	xs_datatype [] = "datatype"
static const xmlChar	xs_default [] = "default"
static const xmlChar	xs_description [] = "description"
static const xmlChar	xs_documentation [] = "documentation"
static const xmlChar	xs_element [] = "element"
static const xmlChar	xs_ElementType [] = "ElementType"
static const xmlChar	xs_eltOnly [] = "eltOnly"
static const xmlChar	xs_enumeration [] = "enumeration"
static const xmlChar	xs_extension [] = "extension"
static const xmlChar	xs_group [] = "group"
static const xmlChar	xs_lax [] = "lax"
static const xmlChar	xs_length [] = "length"
static const xmlChar	xs_many [] = "many"
static const xmlChar	xs_maxOccurs [] = "maxOccurs"
static const xmlChar	xs_minOccurs [] = "minOccurs"
static const xmlChar	xs_mixed [] = "mixed"
static const xmlChar	xs_model [] = "model"
static const xmlChar	xs_name [] = "name"
static const xmlChar	xs_namespace [] = "namespace"
static const xmlChar	xs_no [] = "no"
static const xmlChar	xs_open [] = "open"
static const xmlChar	xs_optional [] = "optional"
static const xmlChar	xs_order [] = "order"
static const xmlChar	xs_processContents [] = "processContents"
static const xmlChar	xs_ref [] = "ref"
static const xmlChar	xs_required [] = "required"
static const xmlChar	xs_restriction [] = "restriction"
static const xmlChar	xs_schema [] = "schema"
static const xmlChar	xs_seq [] = "seq"
static const xmlChar	xs_sequence [] = "sequence"
static const xmlChar	xs_simpleContent [] = "simpleContent"
static const xmlChar	xs_simpleType [] = "simpleType"
static const xmlChar	xs_strict [] = "strict"
static const xmlChar	xs_targetNamespace [] = "targetNamespace"
static const xmlChar	xs_textOnly [] = "textOnly"
static const xmlChar	xs_true [] = "true"
static const xmlChar	xs_type [] = "type"
static const xmlChar	xs_unbounded [] = "unbounded"
static const xmlChar	xs_use [] = "use"
static const xmlChar	xs_value [] = "value"
static const xmlChar	xs_values [] = "values"
static const xmlChar	xs_xsd_string [] = "xsd:string"

Macro Definition Documentation

FOREACH_ATTR

#define FOREACH_ATTR	(		node,
			attr
	)		for (attr = node->properties; attr != NULL; attr = attr->next)

Definition at line 110 of file xdr.c.

FOREACH_CHILD

#define FOREACH_CHILD	(		node,
			child
	)

Value:

    for (child = node->children; child != NULL; child = child->next) \
        if (child->type == XML_ELEMENT_NODE)

Definition at line 106 of file xdr.c.

FOREACH_NS

#define FOREACH_NS	(		node,
			ns
	)		for (ns = node->nsDef; ns != NULL; ns = ns->next)

Definition at line 113 of file xdr.c.

Typedef Documentation

CONTENT_TYPE

typedef enum _CONTENT_TYPE CONTENT_TYPE

ORDER_TYPE

typedef enum _ORDER_TYPE ORDER_TYPE

Enumeration Type Documentation

_CONTENT_TYPE

enum _CONTENT_TYPE

Enumerator
CONTENT_EMPTY
CONTENT_TEXTONLY
CONTENT_ELTONLY
CONTENT_MIXED

Definition at line 91 of file xdr.c.

{
    CONTENT_EMPTY,
    CONTENT_TEXTONLY,
    CONTENT_ELTONLY,
    CONTENT_MIXED
} CONTENT_TYPE;

_ORDER_TYPE

enum _ORDER_TYPE

Enumerator
ORDER_SEQ
ORDER_MANY
ORDER_ONE

Definition at line 99 of file xdr.c.

{
    ORDER_SEQ,
    ORDER_MANY,
    ORDER_ONE
} ORDER_TYPE;

Function Documentation

add_any_child()

static xmlNodePtr add_any_child ( xmlNodePtr  parent, BOOL  set_occurs  )

inlinestatic

Definition at line 198 of file xdr.c.

{
    xmlNodePtr child = xmlNewChild(parent, NULL, xs_any, NULL);
    if (set_occurs)
    {
        xmlSetProp(child, xs_minOccurs, BAD_CAST "0");
        xmlSetProp(child, xs_maxOccurs, xs_unbounded);
    }
    xmlSetProp(child, xs_processContents, xs_strict);
    return child;
}

Referenced by XDR_E_ElementType().

add_anyAttribute_child()

static xmlNodePtr add_anyAttribute_child ( xmlNodePtr  parent )

inlinestatic

Definition at line 210 of file xdr.c.

{
    xmlNodePtr child = xmlNewChild(parent, NULL, xs_anyAttribute, NULL);
    xmlSetProp(child, xs_processContents, xs_lax);
    return child;
}

Referenced by XDR_E_ElementType().

copy_prop_ignore_ns()

static xmlAttrPtr copy_prop_ignore_ns ( xmlAttrPtr  xdr_attr, xmlNodePtr  node  )

inlinestatic

Definition at line 217 of file xdr.c.

{
    xmlChar* str = get_attr_val(xdr_attr);
    xmlAttrPtr attr = xmlSetProp(node, xdr_attr->name, str);
    xmlFree(str);
    return attr;
}

Referenced by XDR_A_default(), XDR_A_maxOccurs(), XDR_A_minOccurs(), and XDR_A_name().

get_attr_val()

static xmlChar * get_attr_val ( xmlAttrPtr  attr )

inlinestatic

Definition at line 193 of file xdr.c.

{
    return xmlNodeGetContent((xmlNodePtr)attr);
}

Referenced by copy_prop_ignore_ns(), XDR_A_dt_type(), XDR_A_maxOccurs(), XDR_A_required(), and XDR_A_type().

get_child()

static xmlNodePtr get_child ( xmlNodePtr  node, xmlChar const *  name  )

inlinestatic

Definition at line 121 of file xdr.c.

{
    xmlNodePtr child = NULL;
    if (node)
    {
        FOREACH_CHILD(node, child)
        {
            if (xmlStrEqual(child->name, name))
                break;
        }
    }
 
    return child;
}

Referenced by get_dt_type(), and XDR_E_ElementType().

get_child_with_attr()

static xmlNodePtr get_child_with_attr ( xmlNodePtr  node, xmlChar const *  name, xmlChar const *  attr_ns, xmlChar const *  attr_name, xmlChar const *  attr_val  )

inlinestatic

Definition at line 136 of file xdr.c.

{
    xmlChar* str;
    if (node)
    {
        FOREACH_CHILD(node, node)
        {
            if (xmlStrEqual(node->name, name))
            {
                str = (attr_ns != NULL)? xmlGetNsProp(node, attr_name, attr_ns) :
                                                  xmlGetProp(node, attr_name);
                if (str)
                {
                    if (xmlStrEqual(str, attr_val))
                    {
                        xmlFree(str);
                        return node;
                    }
                    xmlFree(str);
                }
            }
        }
    }
 
    return NULL;
}

Referenced by XDR_E_attribute().

get_dt_ns()

static xmlNsPtr get_dt_ns ( xmlNodePtr  node )

inlinestatic

Definition at line 165 of file xdr.c.

{
    xmlNsPtr ns;
 
    node = get_schema(node);
    assert(node != NULL);
 
    FOREACH_NS(node, ns)
    {
        if (xmlStrEqual(ns->href, DT_href))
            break;
    }
 
    return ns;
}

Referenced by XDR_A_dt_type(), XDR_E_AttributeType(), and XDR_E_ElementType().

get_dt_type()

static xmlChar * get_dt_type ( xmlNodePtr  xdr )

inlinestatic

Definition at line 181 of file xdr.c.

{
    xmlChar* str = xmlGetNsProp(xdr, xs_type, DT_href);
    if (!str)
    {
        xmlNodePtr datatype = get_child(xdr, xs_datatype);
        if (datatype)
            str = xmlGetNsProp(datatype, xs_type, DT_href);
    }
    return str;
}

Referenced by XDR_E_AttributeType(), and XDR_E_ElementType().

get_schema()

static xmlNodePtr get_schema ( xmlNodePtr  node )

inlinestatic

Definition at line 116 of file xdr.c.

{
    return xmlDocGetRootElement(node->doc);
}

Referenced by get_dt_ns(), and XDR_to_XSD_doc().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

msxml

)

XDR_A_default()

static xmlAttrPtr XDR_A_default ( xmlAttrPtr  xdr_attr, xmlNodePtr  node  )

inlinestatic

Definition at line 224 of file xdr.c.

{
    TRACE("(%p, %p)\n", xdr_attr, node);
 
    return copy_prop_ignore_ns(xdr_attr, node);
}

Referenced by XDR_E_attribute(), and XDR_E_AttributeType().

XDR_A_dt_type()

static xmlAttrPtr XDR_A_dt_type ( xmlAttrPtr  xdr_attr, xmlNodePtr  node  )

inlinestatic

Definition at line 231 of file xdr.c.

{
    xmlChar* str = get_attr_val(xdr_attr);
    xmlAttrPtr attr;
 
    TRACE("(%p, %p)\n", xdr_attr, node);
 
    if (xmlStrEqual(str, xs_enumeration))
        attr = NULL;
    else
        attr = xmlSetNsProp(node, get_dt_ns(node), DT_prefix, str);
    xmlFree(str);
    return attr;
}

Referenced by XDR_E_AttributeType(), and XDR_E_ElementType().

XDR_A_maxOccurs()

static xmlAttrPtr XDR_A_maxOccurs ( xmlAttrPtr  xdr_attr, xmlNodePtr  node  )

static

Definition at line 246 of file xdr.c.

{
    xmlChar* str = get_attr_val(xdr_attr);
    xmlAttrPtr attr;
 
    TRACE("(%p, %p)\n", xdr_attr, node);
 
    if (xmlStrEqual(str, BAD_CAST "*"))
        attr = xmlSetProp(node, xs_maxOccurs, xs_unbounded);
    else
        attr = copy_prop_ignore_ns(xdr_attr, node);
 
    xmlFree(str);
    return attr;
}

Referenced by XDR_E_element(), and XDR_E_group().

XDR_A_minOccurs()

static xmlAttrPtr XDR_A_minOccurs ( xmlAttrPtr  xdr_attr, xmlNodePtr  node  )

inlinestatic

Definition at line 262 of file xdr.c.

{
    TRACE("(%p, %p)\n", xdr_attr, node);
 
    return copy_prop_ignore_ns(xdr_attr, node);
}

Referenced by XDR_E_element(), and XDR_E_group().

XDR_A_name()

static xmlAttrPtr XDR_A_name ( xmlAttrPtr  xdr_attr, xmlNodePtr  node  )

inlinestatic

Definition at line 269 of file xdr.c.

{
    TRACE("(%p, %p)\n", xdr_attr, node);
 
    return copy_prop_ignore_ns(xdr_attr, node);
}

Referenced by XDR_E_AttributeType(), and XDR_E_ElementType().

XDR_A_required()

static xmlAttrPtr XDR_A_required ( xmlAttrPtr  xdr_attr, xmlNodePtr  node  )

static

Definition at line 287 of file xdr.c.

{
    xmlChar* str = get_attr_val(xdr_attr);
    xmlAttrPtr attr;
 
    TRACE("(%p, %p)\n", xdr_attr, node);
 
    if (xmlStrEqual(str, xs_no))
        attr = xmlSetProp(node, xs_use, xs_optional);
    else /* yes */
        attr = xmlSetProp(node, xs_use, xs_required);
    xmlFree(str);
    return attr;
}

Referenced by XDR_E_attribute(), and XDR_E_AttributeType().

XDR_A_type()

static xmlAttrPtr XDR_A_type ( xmlAttrPtr  xdr_attr, xmlNodePtr  node  )

static

Definition at line 276 of file xdr.c.

{
    xmlChar* str = get_attr_val(xdr_attr);
    xmlAttrPtr attr = xmlSetProp(node, xs_ref, str);
 
    TRACE("(%p, %p)\n", xdr_attr, node);
 
    xmlFree(str);
    return attr;
}

Referenced by XDR_E_attribute(), and XDR_E_element().

XDR_E_attribute()

static xmlNodePtr XDR_E_attribute ( xmlNodePtr  xdr, xmlNodePtr  parent  )

static

Definition at line 394 of file xdr.c.

{
    xmlChar* str = xmlGetProp(xdr, xs_type);
    xmlNodePtr xsd_node, xdr_child, xdr_attrType;
    xmlAttrPtr xdr_attr;
 
    TRACE("(%p, %p)\n", xdr, parent);
 
    xdr_attrType = get_child_with_attr(xdr->parent, xs_AttributeType, NULL, xs_name, str);
    xmlFree(str);
 
    if (xdr_attrType)
        xsd_node = XDR_E_AttributeType(xdr_attrType, parent);
    else
        xsd_node = xmlNewChild(parent, NULL, xs_attribute, NULL);
 
    FOREACH_ATTR(xdr, xdr_attr)
    {
        if (xmlStrEqual(xdr_attr->name, xs_default))
            XDR_A_default(xdr_attr, xsd_node);
        else if (xmlStrEqual(xdr_attr->name, xs_type) && !xdr_attrType)
            XDR_A_type(xdr_attr, xsd_node);
        else if (xmlStrEqual(xdr_attr->name, xs_required))
            XDR_A_required(xdr_attr, xsd_node);
        else
            xmlCopyProp(xsd_node, xdr_attr);
    }
 
    FOREACH_CHILD(xdr, xdr_child)
    {
        FIXME("unexpected child <%s>\n", xdr_child->name);
    }
 
    return xsd_node;
}

Referenced by XDR_E_ElementType().

XDR_E_AttributeType()

static xmlNodePtr XDR_E_AttributeType ( xmlNodePtr  xdr, xmlNodePtr  parent  )

static

Definition at line 318 of file xdr.c.

{
    xmlChar *str, *type = get_dt_type(xdr);
    xmlNodePtr xsd_node, xsd_child, xdr_child;
    xmlAttrPtr xdr_attr;
 
    TRACE("(%p, %p)\n", xdr, parent);
 
    xsd_node = xmlNewChild(parent, NULL, xs_attribute, NULL);
 
    if (type && xmlStrEqual(type, xs_enumeration))
    {
        xmlChar *tmp, *tokBegin, *tokEnd = NULL;
        xmlNodePtr xsd_enum;
        xsd_child = xmlNewChild(xsd_node, NULL, xs_simpleType, NULL);
        xsd_child = xmlNewChild(xsd_child, NULL, xs_restriction, NULL);
        xmlSetProp(xsd_child, xs_base, xs_xsd_string);
 
        tokBegin = str = xmlGetNsProp(xdr, xs_values, DT_href);
        while (tokBegin && *tokBegin)
        {
            while (*tokBegin && isspace(*tokBegin))
                ++tokBegin;
            tokEnd = tokBegin;
            while (*tokEnd && !isspace(*tokEnd))
                ++tokEnd;
            if (tokEnd == tokBegin)
                break;
            xsd_enum = xmlNewChild(xsd_child, NULL, xs_enumeration, NULL);
            tmp = xmlStrndup(tokBegin, tokEnd-tokBegin);
            xmlSetProp(xsd_enum, xs_value, tmp);
            xmlFree(tmp);
            tokBegin = tokEnd;
        }
        xmlFree(str);
 
    }
    else if (type)
    {
        str = xmlStrdup(DT_prefix);
        str = xmlStrcat(str, BAD_CAST ":");
        str = xmlStrcat(str, type);
        xmlSetProp(xsd_node, xs_type, str);
        xmlFree(str);
    }
    xmlFree(type);
 
    FOREACH_ATTR(xdr, xdr_attr)
    {
        if (xmlStrEqual(xdr_attr->name, xs_default))
            XDR_A_default(xdr_attr, xsd_node);
        else if (xmlStrEqual(xdr_attr->name, xs_name))
            XDR_A_name(xdr_attr, xsd_node);
        else if (xmlStrEqual(xdr_attr->name, xs_type) && xdr_attr->ns == get_dt_ns(xdr))
            XDR_A_dt_type(xdr_attr, xsd_node);
        else if (xmlStrEqual(xdr_attr->name, xs_values) && xdr_attr->ns == get_dt_ns(xdr))
            ; /* already handled */
        else if (xmlStrEqual(xdr_attr->name, xs_required))
            XDR_A_required(xdr_attr, xsd_node);
        else
            xmlCopyProp(xsd_node, xdr_attr);
    }
 
    FOREACH_CHILD(xdr, xdr_child)
    {
        if (xmlStrEqual(xdr_child->name, xs_datatype))
            ; /* already handled */
        else if (xmlStrEqual(xdr_child->name, xs_description))
            XDR_E_description(xdr_child, xsd_node);
        else
            FIXME("unexpected child <%s>\n", xdr_child->name);
    }
 
    return xsd_node;
}

Referenced by XDR_E_attribute(), and XDR_E_Schema().

XDR_E_description()

static xmlNodePtr XDR_E_description ( xmlNodePtr  xdr, xmlNodePtr  parent  )

static

Definition at line 302 of file xdr.c.

{
    xmlNodePtr xsd_node = xmlNewChild(parent, NULL, xs_annotation, NULL);
    xmlAttrPtr xdr_attr;
 
    TRACE("(%p, %p)\n", xdr, parent);
 
    xmlNewChild(xsd_node, NULL, xs_documentation, xdr->content);
 
    FOREACH_ATTR(xdr, xdr_attr)
    {
        xmlCopyProp(xsd_node, xdr_attr);
    }
    return xsd_node;
}

Referenced by XDR_E_AttributeType(), XDR_E_ElementType(), XDR_E_group(), and XDR_E_Schema().

XDR_E_element()

static xmlNodePtr XDR_E_element ( xmlNodePtr  xdr, xmlNodePtr  parent  )

static

Definition at line 430 of file xdr.c.

{
    xmlNodePtr xdr_child, xsd_node = xmlNewChild(parent, NULL, xs_element, NULL);
    xmlAttrPtr xdr_attr;
 
    FOREACH_ATTR(xdr, xdr_attr)
    {
        if (xmlStrEqual(xdr_attr->name, xs_type))
            XDR_A_type(xdr_attr, xsd_node);
        else if (xmlStrEqual(xdr_attr->name, xs_maxOccurs))
            XDR_A_maxOccurs(xdr_attr, xsd_node);
        else if (xmlStrEqual(xdr_attr->name, xs_minOccurs))
            XDR_A_minOccurs(xdr_attr, xsd_node);
        else
            xmlCopyProp(xsd_node, xdr_attr);
    }
 
    FOREACH_CHILD(xdr, xdr_child)
    {
        FIXME("unexpected child <%s>\n", xdr_child->name);
    }
 
    return xsd_node;
}

Referenced by XDR_E_ElementType(), and XDR_E_group().

XDR_E_ElementType()

static xmlNodePtr XDR_E_ElementType ( xmlNodePtr  xdr, xmlNodePtr  parent  )

static

Definition at line 496 of file xdr.c.

{
    xmlChar *str, *type = get_dt_type(xdr);
    BOOL is_open = TRUE;
    int n_attributes = 0, n_elements = 0, n_groups = 0;
    CONTENT_TYPE content;
    ORDER_TYPE order;
    xmlNodePtr xsd_node, xsd_type, xsd_child, xdr_child;
    xmlAttrPtr xdr_attr;
    xmlNsPtr dt_ns = get_dt_ns(parent);
 
    TRACE("(%p, %p)\n", xdr, parent);
 
    str = xmlGetProp(xdr, xs_model);
    if (str && !xmlStrEqual(str, xs_open))
        is_open = FALSE;
    xmlFree(str);
 
    if (type)
    {
        content = CONTENT_TEXTONLY;
    }
    else
    {
        str = xmlGetProp(xdr, xs_content);
        if (!str || xmlStrEqual(str, xs_mixed))
            content = CONTENT_MIXED;
        else if (xmlStrEqual(str, xs_eltOnly))
            content = CONTENT_ELTONLY;
        else if (xmlStrEqual(str, xs_textOnly))
            content = CONTENT_TEXTONLY;
        else /* empty */
            content = CONTENT_EMPTY;
        xmlFree(str);
    }
 
    str = xmlGetProp(xdr, xs_order);
    if (!str || xmlStrEqual(str, xs_seq))
    {
        order = ORDER_SEQ;
    }
    else if (xmlStrEqual(str, xs_many))
    {
        order = ORDER_MANY;
    }
    else /* one */
    {
        order = ORDER_ONE;
        is_open = FALSE;
    }
    xmlFree(str);
 
    FOREACH_CHILD(xdr, xdr_child)
    {
        if (xmlStrEqual(xdr_child->name, xs_element))
            ++n_elements;
        else if (xmlStrEqual(xdr_child->name, xs_group))
            ++n_groups;
        else if (xmlStrEqual(xdr_child->name, xs_attribute))
            ++n_attributes;
    }
 
    xsd_node = xmlNewChild(parent, NULL, xs_element, NULL);
    assert(xsd_node != NULL);
    switch (content)
    {
        case CONTENT_MIXED:
        case CONTENT_ELTONLY:
            {
                xmlNodePtr xsd_base;
                xsd_type = xmlNewChild(xsd_node, NULL, xs_complexType, NULL);
 
                if (content == CONTENT_MIXED)
                    xmlSetProp(xsd_type, xs_mixed, xs_true);
 
                if (is_open)
                    xsd_base = xmlNewChild(xsd_type, NULL, xs_sequence, NULL);
                else
                    xsd_base = xsd_type;
 
                if (is_open && n_elements < 2 && !n_groups)
                {/* no specific sequence of elements we need,
                    just has to start with the right one, if any */
                    if ((xdr_child = get_child(xdr, xs_element)))
                    {
                        xsd_child = XDR_E_element(xdr_child, xsd_base);
                        xmlUnsetProp(xsd_child, xs_maxOccurs);
                    }
                }
                else
                {
                    switch (order)
                    {
                        case ORDER_SEQ:
                            xsd_child = xmlNewChild(xsd_base, NULL, xs_sequence, NULL);
                            break;
                        case ORDER_MANY:
                            xsd_child = xmlNewChild(xsd_base, NULL, xs_choice, NULL);
                            xmlSetProp(xsd_child, xs_maxOccurs, xs_unbounded);
                            break;
                        case ORDER_ONE:
                            xsd_child = xmlNewChild(xsd_base, NULL, xs_all, NULL);
                            break;
                    }
 
                    FOREACH_CHILD(xdr, xdr_child)
                    {
                        if (xmlStrEqual(xdr_child->name, xs_element))
                            XDR_E_element(xdr_child, xsd_child);
                        else if (xmlStrEqual(xdr_child->name, xs_group))
                            XDR_E_group(xdr_child, xsd_child);
                    }
                }
 
                if (n_attributes)
                {
                    FOREACH_CHILD(xdr, xdr_child)
                    {
                        if (xmlStrEqual(xdr_child->name, xs_attribute))
                            XDR_E_attribute(xdr_child, xsd_type);
                    }
                }
 
                if (is_open)
                {
                    add_any_child(xsd_base, TRUE);
                    add_anyAttribute_child(xsd_type);
                }
            }
            break;
        case CONTENT_TEXTONLY:
            {
                if (is_open)
                {
                    xsd_type = xmlNewChild(xsd_node, NULL, xs_complexType, NULL);
                    if (type)
                    {
                        xsd_child = xmlNewChild(xsd_type, NULL, xs_simpleContent, NULL);
                        xsd_child = xmlNewChild(xsd_child, NULL, xs_extension, NULL);
                        str = xmlStrdup(DT_prefix);
                        str = xmlStrcat(str, BAD_CAST ":");
                        str = xmlStrcat(str, type);
                        xmlSetProp(xsd_child, xs_base, str);
                        xmlFree(str);
                        assert(dt_ns != NULL);
                        xmlSetNsProp(xsd_node, dt_ns, DT_prefix, type);
                    }
                    else
                    {
                        xmlSetProp(xsd_type, xs_mixed, xs_true);
                        xsd_child = xmlNewChild(xsd_type, NULL, xs_choice, NULL);
                        xmlSetProp(xsd_child, xs_minOccurs, BAD_CAST "0");
                        xmlSetProp(xsd_child, xs_maxOccurs, xs_unbounded);
                        xsd_child = add_any_child(xsd_child, FALSE);
                        xmlSetProp(xsd_child, xs_namespace, BAD_CAST "##other");
                        xsd_child = xsd_type;
                    }
 
                    if (n_attributes)
                        FOREACH_CHILD(xdr, xdr_child)
                        {
                            if (xmlStrEqual(xdr_child->name, xs_attribute))
                                XDR_E_attribute(xdr_child, xsd_child);
                        }
 
                    xmlNewChild(xsd_child, NULL, xs_anyAttribute, NULL);
                }
                else if (!n_attributes)
                {
                    if (type)
                    {
                        str = xmlStrdup(DT_prefix);
                        str = xmlStrcat(str, BAD_CAST ":");
                        str = xmlStrcat(str, type);
                        xmlSetProp(xsd_node, xs_type, str);
                        xmlFree(str);
                        str = NULL;
                        xmlSetNsProp(xsd_node, dt_ns, DT_prefix, type);
                    }
                    else
                    {
                        xmlSetProp(xsd_node, xs_type, xs_xsd_string);
                    }
                }
                else
                {
                    xsd_type = xmlNewChild(xsd_node, NULL, xs_complexType, NULL);
                    xsd_child = xmlNewChild(xsd_type, NULL, xs_simpleContent, NULL);
                    xsd_child = xmlNewChild(xsd_child, NULL, xs_extension, NULL);
                    xmlSetProp(xsd_child, xs_base, xs_xsd_string);
 
                    FOREACH_CHILD(xdr, xdr_child)
                    {
                        if (xmlStrEqual(xdr_child->name, xs_attribute))
                            XDR_E_attribute(xdr_child, xsd_child);
                    }
                }
            }
            break;
        case CONTENT_EMPTY: /* not allowed with model="open" */
            {
                if (n_attributes)
                {
                    xsd_type = xmlNewChild(xsd_node, NULL, xs_complexType, NULL);
 
                    FOREACH_CHILD(xdr, xdr_child)
                    {
                        if (xmlStrEqual(xdr_child->name, xs_attribute))
                            XDR_E_attribute(xdr_child, xsd_type);
                    }
                }
                else
                {
                    xsd_type = xmlNewChild(xsd_node, NULL, xs_simpleType, NULL);
                    xsd_child = xmlNewChild(xsd_type, NULL, xs_restriction, NULL);
                    xmlSetProp(xsd_child, xs_base, xs_xsd_string);
                    xsd_child = xmlNewChild(xsd_child, NULL, xs_length, NULL);
                    xmlSetProp(xsd_child, xs_value, BAD_CAST "0");
                }
            }
            break;
    }
    xmlFree(type);
 
    FOREACH_ATTR(xdr, xdr_attr)
    {
        if (xmlStrEqual(xdr_attr->name, xs_content))
            ; /* already handled */
        else if (xmlStrEqual(xdr_attr->name, xs_name))
            XDR_A_name(xdr_attr, xsd_node);
        else if (xmlStrEqual(xdr_attr->name, xs_type) && xdr_attr->ns == get_dt_ns(xdr))
            XDR_A_dt_type(xdr_attr, xsd_node);
        else if (xmlStrEqual(xdr_attr->name, xs_model))
            ; /* already handled */
        else if (xmlStrEqual(xdr_attr->name, xs_order))
            ; /* already handled */
        else
            xmlCopyProp(xsd_node, xdr_attr);
 
    }
 
    FOREACH_CHILD(xdr, xdr_child)
    {
        if (xmlStrEqual(xdr_child->name, xs_attribute))
            ; /* already handled */
        else if (xmlStrEqual(xdr_child->name, xs_AttributeType))
            ; /* handled through XDR_E_attribute when parent is not <Schema> */
        else if (xmlStrEqual(xdr_child->name, xs_datatype))
            ; /* already handled */
        else if (xmlStrEqual(xdr_child->name, xs_description))
            XDR_E_description(xdr_child, xsd_node);
        else if (xmlStrEqual(xdr_child->name, xs_element))
            ; /* already handled */
        else if (xmlStrEqual(xdr_child->name, xs_group))
            ; /* already handled */
        else
            FIXME("unexpected child <%s>\n", xdr_child->name);
    }
 
    return xsd_node;
}

Referenced by XDR_E_Schema().

XDR_E_group()

static xmlNodePtr XDR_E_group ( xmlNodePtr  xdr, xmlNodePtr  parent  )

static

Definition at line 455 of file xdr.c.

{
    xmlNodePtr xdr_child, xsd_node;
    xmlChar* str = xmlGetProp(xdr, xs_order);
    xmlAttrPtr xdr_attr;
 
    TRACE("(%p, %p)\n", xdr, parent);
 
    if (!str || xmlStrEqual(str, xs_seq))
        xsd_node = xmlNewChild(parent, NULL, xs_sequence, NULL);
    else if (xmlStrEqual(str, xs_many))
        xsd_node = xmlNewChild(parent, NULL, xs_choice, NULL);
    else /* one */
        xsd_node = xmlNewChild(parent, NULL, xs_all, NULL);
    xmlFree(str);
 
    FOREACH_ATTR(xdr, xdr_attr)
    {
        if (xmlStrEqual(xdr_attr->name, xs_order))
            ; /* already handled */
        else if (xmlStrEqual(xdr_attr->name, xs_model))
            ; /* ignored */
        else if (xmlStrEqual(xdr_attr->name, xs_maxOccurs))
            XDR_A_maxOccurs(xdr_attr, xsd_node);
        else if (xmlStrEqual(xdr_attr->name, xs_minOccurs))
            XDR_A_minOccurs(xdr_attr, xsd_node);
        else
            xmlCopyProp(xsd_node, xdr_attr);
    }
 
    FOREACH_CHILD(xdr, xdr_child)
    {
        if (xmlStrEqual(xdr_child->name, xs_description))
            XDR_E_description(xdr_child, xsd_node);
        else if (xmlStrEqual(xdr_child->name, xs_element))
            XDR_E_element(xdr_child, xsd_node);
    }
 
    return xsd_node;
}

Referenced by XDR_E_ElementType().

XDR_E_Schema()

static xmlNodePtr XDR_E_Schema ( xmlNodePtr  xdr, xmlNodePtr  parent, xmlChar const *  nsURI  )

static

Definition at line 758 of file xdr.c.

{
    xmlNodePtr xsd_node, xdr_child;
    xmlNsPtr ns, xdr_ns;
    xmlAttrPtr xdr_attr;
 
    TRACE("(%p, %p)\n", xdr, parent);
 
    xsd_node = xmlNewDocNode((xmlDocPtr)parent, NULL, xs_schema, NULL);
    xmlDocSetRootElement((xmlDocPtr)parent, xsd_node);
    assert(xsd_node != NULL);
 
    if (nsURI && *nsURI) xmlNewNs(xsd_node, nsURI, NULL);
    ns = xmlNewNs(xsd_node, XSD_href, XSD_prefix);
    assert(ns != NULL);
 
    xmlSetNs(xsd_node, ns);
 
    if (nsURI && *nsURI) xmlSetProp(xsd_node, xs_targetNamespace, nsURI);
 
    FOREACH_NS(xdr, xdr_ns)
    {
        /* TODO: special handling for dt namespace? */
        assert(xdr_ns->href != NULL);
        if (xmlStrEqual(xdr_ns->href, XDR_href))
            ; /* ignored */
        else if (xdr_ns->prefix != NULL)
            xmlNewNs(xsd_node, xdr_ns->href, xdr_ns->prefix);
        else
            FIXME("unexpected default xmlns: %s\n", xdr_ns->href);
    }
 
    FOREACH_ATTR(xdr, xdr_attr)
    {
        xmlCopyProp(xsd_node, xdr_attr);
    }
 
    FOREACH_CHILD(xdr, xdr_child)
    {
        if (xmlStrEqual(xdr_child->name, xs_AttributeType))
            XDR_E_AttributeType(xdr_child, xsd_node);
        else if (xmlStrEqual(xdr_child->name, xs_description))
            XDR_E_description(xdr_child, xsd_node);
        else if (xmlStrEqual(xdr_child->name, xs_ElementType))
            XDR_E_ElementType(xdr_child, xsd_node);
        else
            FIXME("unexpected child <%s>\n", xdr_child->name);
    }
 
    return xsd_node;
}

Referenced by XDR_to_XSD_doc().

XDR_to_XSD_doc()

xmlDocPtr XDR_to_XSD_doc	(	xmlDocPtr	xdr_doc,
		xmlChar const *	nsURI
	)

Definition at line 810 of file xdr.c.

{
    xmlDocPtr xsd_doc = xmlNewDoc(NULL);
 
    TRACE("(%p)\n", xdr_doc);
 
    XDR_E_Schema(get_schema((xmlNodePtr)xdr_doc), (xmlNodePtr)xsd_doc, nsURI);
 
    return xsd_doc;
}

Referenced by cache_entry_from_xdr_doc().

Variable Documentation

DT_href

const xmlChar DT_href[] = "urn:schemas-microsoft-com:datatypes"

static

Definition at line 33 of file xdr.c.

Referenced by get_dt_ns(), get_dt_type(), and XDR_E_AttributeType().

DT_prefix

const xmlChar DT_prefix[] = "dt"

static

Definition at line 32 of file xdr.c.

Referenced by XDR_A_dt_type(), XDR_E_AttributeType(), and XDR_E_ElementType().

XDR_href

const xmlChar XDR_href[] = "urn:schemas-microsoft-com:xml-data"

static

Definition at line 34 of file xdr.c.

Referenced by XDR_E_Schema().

xs_all

const xmlChar xs_all[] = "all"

static

Definition at line 38 of file xdr.c.

Referenced by XDR_E_ElementType(), and XDR_E_group().

xs_annotation

const xmlChar xs_annotation[] = "annotation"

static

Definition at line 39 of file xdr.c.

Referenced by XDR_E_description().

xs_any

const xmlChar xs_any[] = "any"

static

Definition at line 40 of file xdr.c.

Referenced by add_any_child().

xs_anyAttribute

const xmlChar xs_anyAttribute[] = "anyAttribute"

static

Definition at line 41 of file xdr.c.

Referenced by add_anyAttribute_child(), and XDR_E_ElementType().

xs_attribute

const xmlChar xs_attribute[] = "attribute"

static

Definition at line 42 of file xdr.c.

Referenced by XDR_E_attribute(), XDR_E_AttributeType(), and XDR_E_ElementType().

xs_AttributeType

const xmlChar xs_AttributeType[] = "AttributeType"

static

Definition at line 43 of file xdr.c.

Referenced by XDR_E_attribute(), XDR_E_ElementType(), and XDR_E_Schema().

xs_base

const xmlChar xs_base[] = "base"

static

Definition at line 44 of file xdr.c.

Referenced by XDR_E_AttributeType(), and XDR_E_ElementType().

xs_choice

const xmlChar xs_choice[] = "choice"

static

Definition at line 45 of file xdr.c.

Referenced by XDR_E_ElementType(), and XDR_E_group().

xs_complexType

const xmlChar xs_complexType[] = "complexType"

static

Definition at line 46 of file xdr.c.

Referenced by XDR_E_ElementType().

xs_content

const xmlChar xs_content[] = "content"

static

Definition at line 47 of file xdr.c.

Referenced by XDR_E_ElementType().

xs_datatype

const xmlChar xs_datatype[] = "datatype"

static

Definition at line 48 of file xdr.c.

Referenced by get_dt_type(), XDR_E_AttributeType(), and XDR_E_ElementType().

xs_default

const xmlChar xs_default[] = "default"

static

Definition at line 49 of file xdr.c.

Referenced by XDR_E_attribute(), and XDR_E_AttributeType().

xs_description

const xmlChar xs_description[] = "description"

static

Definition at line 50 of file xdr.c.

Referenced by XDR_E_AttributeType(), XDR_E_ElementType(), XDR_E_group(), and XDR_E_Schema().

xs_documentation

const xmlChar xs_documentation[] = "documentation"

static

Definition at line 51 of file xdr.c.

Referenced by XDR_E_description().

xs_element

const xmlChar xs_element[] = "element"

static

Definition at line 52 of file xdr.c.

Referenced by XDR_E_element(), XDR_E_ElementType(), and XDR_E_group().

xs_ElementType

const xmlChar xs_ElementType[] = "ElementType"

static

Definition at line 53 of file xdr.c.

Referenced by XDR_E_Schema().

xs_eltOnly

const xmlChar xs_eltOnly[] = "eltOnly"

static

Definition at line 54 of file xdr.c.

Referenced by XDR_E_ElementType().

xs_enumeration

const xmlChar xs_enumeration[] = "enumeration"

static

Definition at line 55 of file xdr.c.

Referenced by XDR_A_dt_type(), and XDR_E_AttributeType().

xs_extension

const xmlChar xs_extension[] = "extension"

static

Definition at line 56 of file xdr.c.

Referenced by XDR_E_ElementType().

xs_group

const xmlChar xs_group[] = "group"

static

Definition at line 57 of file xdr.c.

Referenced by XDR_E_ElementType().

xs_lax

const xmlChar xs_lax[] = "lax"

static

Definition at line 58 of file xdr.c.

Referenced by add_anyAttribute_child().

xs_length

const xmlChar xs_length[] = "length"

static

Definition at line 59 of file xdr.c.

Referenced by XDR_E_ElementType().

xs_many

const xmlChar xs_many[] = "many"

static

Definition at line 60 of file xdr.c.

Referenced by XDR_E_ElementType(), and XDR_E_group().

xs_maxOccurs

const xmlChar xs_maxOccurs[] = "maxOccurs"

static

Definition at line 61 of file xdr.c.

Referenced by add_any_child(), XDR_A_maxOccurs(), XDR_E_element(), XDR_E_ElementType(), and XDR_E_group().

xs_minOccurs

const xmlChar xs_minOccurs[] = "minOccurs"

static

Definition at line 62 of file xdr.c.

Referenced by add_any_child(), XDR_E_element(), XDR_E_ElementType(), and XDR_E_group().

xs_mixed

const xmlChar xs_mixed[] = "mixed"

static

Definition at line 63 of file xdr.c.

Referenced by XDR_E_ElementType().

xs_model

const xmlChar xs_model[] = "model"

static

Definition at line 64 of file xdr.c.

Referenced by XDR_E_ElementType(), and XDR_E_group().

xs_name

const xmlChar xs_name[] = "name"

static

Definition at line 65 of file xdr.c.

Referenced by XDR_E_attribute(), XDR_E_AttributeType(), and XDR_E_ElementType().

xs_namespace

const xmlChar xs_namespace[] = "namespace"

static

Definition at line 66 of file xdr.c.

Referenced by XDR_E_ElementType().

xs_no

const xmlChar xs_no[] = "no"

static

Definition at line 67 of file xdr.c.

Referenced by XDR_A_required().

xs_open

const xmlChar xs_open[] = "open"

static

Definition at line 68 of file xdr.c.

Referenced by XDR_E_ElementType().

xs_optional

const xmlChar xs_optional[] = "optional"

static

Definition at line 69 of file xdr.c.

Referenced by XDR_A_required().

xs_order

const xmlChar xs_order[] = "order"

static

Definition at line 70 of file xdr.c.

Referenced by XDR_E_ElementType(), and XDR_E_group().

xs_processContents

const xmlChar xs_processContents[] = "processContents"

static

Definition at line 71 of file xdr.c.

Referenced by add_any_child(), and add_anyAttribute_child().

xs_ref

const xmlChar xs_ref[] = "ref"

static

Definition at line 72 of file xdr.c.

Referenced by XDR_A_type().

xs_required

const xmlChar xs_required[] = "required"

static

Definition at line 73 of file xdr.c.

Referenced by XDR_A_required(), XDR_E_attribute(), and XDR_E_AttributeType().

xs_restriction

const xmlChar xs_restriction[] = "restriction"

static

Definition at line 74 of file xdr.c.

Referenced by XDR_E_AttributeType(), and XDR_E_ElementType().

xs_schema

const xmlChar xs_schema[] = "schema"

static

Definition at line 75 of file xdr.c.

Referenced by XDR_E_Schema().

xs_seq

const xmlChar xs_seq[] = "seq"

static

Definition at line 76 of file xdr.c.

Referenced by XDR_E_ElementType(), and XDR_E_group().

xs_sequence

const xmlChar xs_sequence[] = "sequence"

static

Definition at line 77 of file xdr.c.

Referenced by XDR_E_ElementType(), and XDR_E_group().

xs_simpleContent

const xmlChar xs_simpleContent[] = "simpleContent"

static

Definition at line 78 of file xdr.c.

Referenced by XDR_E_ElementType().

xs_simpleType

const xmlChar xs_simpleType[] = "simpleType"

static

Definition at line 79 of file xdr.c.

Referenced by XDR_E_AttributeType(), and XDR_E_ElementType().

xs_strict

const xmlChar xs_strict[] = "strict"

static

Definition at line 80 of file xdr.c.

Referenced by add_any_child().

xs_targetNamespace

const xmlChar xs_targetNamespace[] = "targetNamespace"

static

Definition at line 81 of file xdr.c.

Referenced by XDR_E_Schema().

xs_textOnly

const xmlChar xs_textOnly[] = "textOnly"

static

Definition at line 82 of file xdr.c.

Referenced by XDR_E_ElementType().

xs_true

const xmlChar xs_true[] = "true"

static

Definition at line 83 of file xdr.c.

Referenced by XDR_E_ElementType().

xs_type

const xmlChar xs_type[] = "type"

static

Definition at line 84 of file xdr.c.

Referenced by get_dt_type(), XDR_E_attribute(), XDR_E_AttributeType(), XDR_E_element(), and XDR_E_ElementType().

xs_unbounded

const xmlChar xs_unbounded[] = "unbounded"

static

Definition at line 85 of file xdr.c.

Referenced by add_any_child(), XDR_A_maxOccurs(), and XDR_E_ElementType().

xs_use

const xmlChar xs_use[] = "use"

static

Definition at line 86 of file xdr.c.

Referenced by XDR_A_required().

xs_value

const xmlChar xs_value[] = "value"

static

Definition at line 87 of file xdr.c.

Referenced by XDR_E_AttributeType(), and XDR_E_ElementType().

xs_values

const xmlChar xs_values[] = "values"

static

Definition at line 88 of file xdr.c.

Referenced by XDR_E_AttributeType().

xs_xsd_string

const xmlChar xs_xsd_string[] = "xsd:string"

static

Definition at line 89 of file xdr.c.

Referenced by XDR_E_AttributeType(), and XDR_E_ElementType().

XSD_href

const xmlChar XSD_href[] = "http://www.w3.org/2001/XMLSchema"

static

Definition at line 36 of file xdr.c.

Referenced by XDR_E_Schema().

XSD_prefix

const xmlChar XSD_prefix[] = "xsd"

static

Definition at line 35 of file xdr.c.

Referenced by XDR_E_Schema().