php-src/ext/soap/php_schema.c
2004-01-19 00:10:41 +00:00

1065 lines
30 KiB
C

#include "php_soap.h"
static int schema_simpleType(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr simpleType, sdlTypePtr cur_type);
static int schema_complexType(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr compType, sdlTypePtr cur_type);
static int schema_sequence(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr seqType, sdlTypePtr cur_type);
static int schema_list(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr listType, sdlTypePtr cur_type);
static int schema_union(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr unionType, sdlTypePtr cur_type);
static int schema_simpleContent(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr simpCompType, sdlTypePtr cur_type);
static int schema_restriction_simpleType(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr restType, sdlTypePtr cur_type);
static int schema_restriction_simpleContent(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr restType, sdlTypePtr cur_type);
static int schema_restriction_complexContent(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr restType, sdlTypePtr cur_type);
static int schema_extension_simpleContent(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr extType, sdlTypePtr cur_type);
static int schema_extension_complexContent(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr extType, sdlTypePtr cur_type);
static int schema_all(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr extType, sdlTypePtr cur_type);
static int schema_group(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr groupType, sdlTypePtr cur_type);
static int schema_choice(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr choiceType, sdlTypePtr cur_type);
static int schema_element(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr element, sdlTypePtr cur_type);
static int schema_attribute(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr attrType, sdlTypePtr cur_type);
static int schema_any(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr extType, sdlTypePtr cur_type);
static int schema_restriction_var_int(xmlNodePtr val, sdlRestrictionIntPtr *valptr);
static int schema_restriction_var_char(xmlNodePtr val, sdlRestrictionCharPtr *valptr);
/*
2.6.1 xsi:type
2.6.2 xsi:nil
2.6.3 xsi:schemaLocation, xsi:noNamespaceSchemaLocation
*/
/*
<schema
attributeFormDefault = (qualified | unqualified) : unqualified
blockDefault = (#all | List of (extension | restriction | substitution)) : ''
elementFormDefault = (qualified | unqualified) : unqualified
finalDefault = (#all | List of (extension | restriction)) : ''
id = ID
targetNamespace = anyURI
version = token
xml:lang = language
{any attributes with non-schema namespace . . .}>
Content: ((include | import | redefine | annotation)*, (((simpleType | complexType | group | attributeGroup) | element | attribute | notation), annotation*)*)
</schema>
*/
int load_schema(sdlPtr sdl,xmlNodePtr schema)
{
xmlNodePtr trav, element, compType, simpleType, attribute, include;
xmlAttrPtr tns;
if (!sdl->types) {
sdl->types = malloc(sizeof(HashTable));
zend_hash_init(sdl->types, 0, NULL, delete_type, 1);
}
tns = get_attribute(schema->properties, "targetNamespace");
trav = schema->children;
FOREACHNODE(trav,"import",include) {
xmlAttrPtr tmp = get_attribute(include->properties, "schemaLocation");
if (tmp) {
/* TODO: schema import */
/*load_wsdl_ex(tmp->children->content, ctx, 1);*/
}
}
ENDFOREACH(trav);
trav = schema->children;
FOREACHNODE(trav,"simpleType",simpleType) {
schema_simpleType(sdl, tns, simpleType, NULL);
}
ENDFOREACH(trav);
trav = schema->children;
FOREACHNODE(trav,"complexType",compType) {
schema_complexType(sdl, tns, compType, NULL);
}
ENDFOREACH(trav);
trav = schema->children;
FOREACHNODE(trav,"element",element) {
schema_element(sdl, tns, element, NULL);
}
ENDFOREACH(trav);
trav = schema->children;
FOREACHNODE(trav, "attribute", attribute) {
schema_attribute(sdl, tns, attribute, NULL);
}
ENDFOREACH(trav);
return FALSE;
}
/*
<simpleType
final = (#all | (list | union | restriction))
id = ID
name = NCName
{any attributes with non-schema namespace . . .}>
Content: (annotation?, (restriction | list | union))
</simpleType>
*/
static int schema_simpleType(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr simpleType, sdlTypePtr cur_type)
{
xmlNodePtr content;
xmlAttrPtr name, ns;
ns = get_attribute(simpleType->properties, "targetNamespace");
if (ns == NULL) {
ns = tsn;
}
name = get_attribute(simpleType->properties, "name");
if (name != NULL) {
HashTable *ht;
smart_str key = {0};
sdlTypePtr newType, *ptr;
newType = malloc(sizeof(sdlType));
memset(newType, 0, sizeof(sdlType));
newType->name = strdup(name->children->content);
newType->namens = strdup(ns->children->content);
if (cur_type == NULL) {
ht = sdl->types;
smart_str_appends(&key, newType->namens);
smart_str_appendc(&key, ':');
smart_str_appends(&key, newType->name);
smart_str_0(&key);
} else {
if (cur_type->elements == NULL) {
cur_type->elements = malloc(sizeof(HashTable));
zend_hash_init(cur_type->elements, 0, NULL, delete_type, 1);
}
ht = cur_type->elements;
smart_str_appends(&key, cur_type->name);
smart_str_0(&key);
}
zend_hash_update(ht, key.c, key.len + 1, &newType, sizeof(sdlTypePtr), (void **)&ptr);
cur_type = (*ptr);
create_encoder(sdl, cur_type, ns->children->content, name->children->content);
smart_str_free(&key);
}
content = get_node(simpleType->children, "restriction");
if (content != NULL) {
schema_restriction_simpleType(sdl, tsn, content, cur_type);
return TRUE;
}
content = get_node(simpleType->children, "list");
if (content != NULL) {
schema_list(sdl, tsn, content, cur_type);
return TRUE;
}
content = get_node(simpleType->children, "union");
if (content != NULL) {
schema_union(sdl, tsn, content, cur_type);
return TRUE;
}
return FALSE;
}
/*
<list
id = ID
itemType = QName
{any attributes with non-schema namespace . . .}>
Content: (annotation?, (simpleType?))
</list>
*/
static int schema_list(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr listType, sdlTypePtr cur_type)
{
return TRUE;
}
/*
<union
id = ID
memberTypes = List of QName
{any attributes with non-schema namespace . . .}>
Content: (annotation?, (simpleType*))
</union>
*/
static int schema_union(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr unionType, sdlTypePtr cur_type)
{
return TRUE;
}
/*
<simpleContent
id = ID
{any attributes with non-schema namespace . . .}>
Content: (annotation?, (restriction | extension))
</simpleContent>
*/
static int schema_simpleContent(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr simpCompType, sdlTypePtr cur_type)
{
xmlNodePtr content;
content = get_node(simpCompType->children, "restriction");
if (content != NULL) {
schema_restriction_simpleContent(sdl, tsn, content, cur_type);
return TRUE;
}
content = get_node(simpCompType->children, "extension");
if (content != NULL) {
schema_extension_simpleContent(sdl, tsn, content, cur_type);
return TRUE;
}
php_error(E_ERROR, "Error parsing schema (simpleContent)");
return FALSE;
}
/*
<restriction
base = QName
id = ID
{any attributes with non-schema namespace . . .}>
Content: (annotation?, (simpleType?, (minExclusive | minInclusive | maxExclusive | maxInclusive | totalDigits | fractionDigits | length | minLength | maxLength | enumeration | whiteSpace | pattern)*)?, ((attribute | attributeGroup)*, anyAttribute?))
</restriction>
*/
static int schema_restriction_simpleType(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr restType, sdlTypePtr cur_type)
{
xmlNodePtr content, trav;
xmlAttrPtr base;
content = get_node(restType->children, "simpleType");
if (content != NULL) {
schema_simpleType(sdl, tsn, content, cur_type);
return TRUE;
}
base = get_attribute(restType->properties, "base");
if (base != NULL) {
char *type, *ns;
xmlNsPtr nsptr;
parse_namespace(base->children->content, &type, &ns);
nsptr = xmlSearchNs(restType->doc, restType, ns);
if (nsptr != NULL) {
cur_type->encode = get_encoder(sdl, (char *)nsptr->href, type);
}
if (type) {efree(type);}
if (ns) {efree(ns);}
}
if (cur_type->restrictions == NULL) {
cur_type->restrictions = malloc(sizeof(sdlRestrictions));
memset(cur_type->restrictions, 0, sizeof(sdlRestrictions));
}
trav = restType->children;
while (trav != NULL) {
if (trav->type == XML_ELEMENT_NODE) {
if (!strcmp(trav->name, "minExclusive")) {
schema_restriction_var_int(trav, &cur_type->restrictions->minExclusive);
} else if (!strcmp(trav->name, "minInclusive")) {
schema_restriction_var_int(trav, &cur_type->restrictions->minInclusive);
} else if (!strcmp(trav->name, "maxExclusive")) {
schema_restriction_var_int(trav, &cur_type->restrictions->maxExclusive);
} else if (!strcmp(trav->name, "maxInclusive")) {
schema_restriction_var_int(trav, &cur_type->restrictions->maxInclusive);
} else if (!strcmp(trav->name, "totalDigits")) {
schema_restriction_var_int(trav, &cur_type->restrictions->totalDigits);
} else if (!strcmp(trav->name, "fractionDigits")) {
schema_restriction_var_int(trav, &cur_type->restrictions->fractionDigits);
} else if (!strcmp(trav->name, "length")) {
schema_restriction_var_int(trav, &cur_type->restrictions->length);
} else if (!strcmp(trav->name, "minLength")) {
schema_restriction_var_int(trav, &cur_type->restrictions->minLength);
} else if (!strcmp(trav->name, "maxLength")) {
schema_restriction_var_int(trav, &cur_type->restrictions->maxLength);
} else if (!strcmp(trav->name, "whiteSpace")) {
schema_restriction_var_char(trav, &cur_type->restrictions->whiteSpace);
} else if (!strcmp(trav->name, "pattern")) {
schema_restriction_var_char(trav, &cur_type->restrictions->pattern);
} else if (!strcmp(trav->name, "enumeration")) {
sdlRestrictionCharPtr enumval = NULL;
schema_restriction_var_char(trav, &enumval);
if (cur_type->restrictions->enumeration == NULL) {
cur_type->restrictions->enumeration = malloc(sizeof(HashTable));
zend_hash_init(cur_type->restrictions->enumeration, 0, NULL, delete_schema_restriction_var_char, 1);
}
zend_hash_add(cur_type->restrictions->enumeration, enumval->value, strlen(enumval->value)+1, &enumval, sizeof(sdlRestrictionCharPtr), NULL);
}
}
trav = trav->next;
}
return TRUE;
}
/*
<restriction
base = QName
id = ID
{any attributes with non-schema namespace . . .}>
Content: (annotation?, (group | all | choice | sequence)?, ((attribute | attributeGroup)*, anyAttribute?))
</restriction>
*/
static int schema_restriction_complexContent(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr restType, sdlTypePtr cur_type)
{
xmlAttrPtr base;
xmlNodePtr trav;
base = get_attribute(restType->properties, "base");
if (base != NULL) {
char *type, *ns;
xmlNsPtr nsptr;
parse_namespace(base->children->content, &type, &ns);
nsptr = xmlSearchNs(restType->doc, restType, ns);
if (nsptr != NULL) {
cur_type->encode = get_encoder(sdl, (char *)nsptr->href, type);
}
if (type) {efree(type);}
if (ns) {efree(ns);}
}
trav = restType->children;
while (trav != NULL) {
if (trav->type == XML_ELEMENT_NODE) {
if (!strcmp(trav->name, "group")) {
schema_group(sdl, tsn, trav, cur_type);
break;
} else if (!strcmp(trav->name, "all")) {
schema_all(sdl, tsn, trav, cur_type);
break;
} else if (!strcmp(trav->name, "choice")) {
schema_choice(sdl, tsn, trav, cur_type);
break;
} else if (!strcmp(trav->name, "sequence")) {
schema_sequence(sdl, tsn, trav, cur_type);
break;
} else if (!strcmp(trav->name, "attribute")) {
schema_attribute(sdl, tsn, trav, cur_type);
}
}
trav = trav->next;
}
while (trav != NULL) {
if (trav->type == XML_ELEMENT_NODE) {
if (!strcmp(trav->name, "attribute")) {
schema_attribute(sdl, tsn, trav, cur_type);
}
}
trav = trav->next;
}
return TRUE;
}
/*
<restriction
base = QName
id = ID
{any attributes with non-schema Namespace . . .}>
Content: (annotation?, (simpleType?, (minExclusive | minInclusive | maxExclusive | maxInclusive | totalDigits | fractionDigits | length | minLength | maxLength | enumeration | whiteSpace | pattern)*))
</restriction>
*/
static int schema_restriction_simpleContent(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr restType, sdlTypePtr cur_type)
{
xmlNodePtr content, trav;
xmlAttrPtr base;
base = get_attribute(restType->properties, "base");
if (base != NULL) {
cur_type->encode = get_encoder_from_prefix(sdl, restType, base->children->content);
}
content = get_node(restType->children, "simpleType");
if (content != NULL) {
schema_simpleType(sdl, tsn, content, cur_type);
return TRUE;
}
if (cur_type->restrictions == NULL) {
cur_type->restrictions = malloc(sizeof(sdlRestrictions));
memset(cur_type->restrictions, 0, sizeof(sdlRestrictions));
}
trav = restType->children;
while (trav != NULL) {
if (trav->type == XML_ELEMENT_NODE) {
if (!strcmp(trav->name, "minExclusive")) {
schema_restriction_var_int(trav, &cur_type->restrictions->minExclusive);
} else if (!strcmp(trav->name, "minInclusive")) {
schema_restriction_var_int(trav, &cur_type->restrictions->minInclusive);
} else if (!strcmp(trav->name, "maxExclusive")) {
schema_restriction_var_int(trav, &cur_type->restrictions->maxExclusive);
} else if (!strcmp(trav->name, "maxInclusive")) {
schema_restriction_var_int(trav, &cur_type->restrictions->maxInclusive);
} else if (!strcmp(trav->name, "totalDigits")) {
schema_restriction_var_int(trav, &cur_type->restrictions->totalDigits);
} else if (!strcmp(trav->name, "fractionDigits")) {
schema_restriction_var_int(trav, &cur_type->restrictions->fractionDigits);
} else if (!strcmp(trav->name, "length")) {
schema_restriction_var_int(trav, &cur_type->restrictions->length);
} else if (!strcmp(trav->name, "minLength")) {
schema_restriction_var_int(trav, &cur_type->restrictions->minLength);
} else if (!strcmp(trav->name, "maxLength")) {
schema_restriction_var_int(trav, &cur_type->restrictions->maxLength);
} else if (!strcmp(trav->name, "whiteSpace")) {
schema_restriction_var_char(trav, &cur_type->restrictions->whiteSpace);
} else if (!strcmp(trav->name, "pattern")) {
schema_restriction_var_char(trav, &cur_type->restrictions->pattern);
} else if (!strcmp(trav->name, "enumeration")) {
sdlRestrictionCharPtr enumval = NULL;
schema_restriction_var_char(trav, &enumval);
if (cur_type->restrictions->enumeration == NULL) {
cur_type->restrictions->enumeration = malloc(sizeof(HashTable));
zend_hash_init(cur_type->restrictions->enumeration, 0, NULL, delete_schema_restriction_var_char, 1);
}
zend_hash_add(cur_type->restrictions->enumeration, enumval->value, strlen(enumval->value)+1, &enumval, sizeof(sdlRestrictionCharPtr), NULL);
}
}
trav = trav->next;
}
return TRUE;
}
static int schema_restriction_var_int(xmlNodePtr val, sdlRestrictionIntPtr *valptr)
{
xmlAttrPtr fixed, value, id;
if ((*valptr) == NULL) {
(*valptr) = malloc(sizeof(sdlRestrictionInt));
}
memset((*valptr), 0, sizeof(sdlRestrictionInt));
fixed = get_attribute(val->properties, "fixed");
(*valptr)->fixed = FALSE;
if (fixed != NULL) {
if (!strcmp(fixed->children->content, "true") ||
!strcmp(fixed->children->content, "1"))
(*valptr)->fixed = TRUE;
}
id = get_attribute(val->properties, "id");
if (id != NULL) {
(*valptr)->id = strdup(id->children->content);
}
value = get_attribute(val->properties, "value");
if (value == NULL) {
php_error(E_ERROR, "Error parsing wsdl schema \"missing restriction value\"");
}
(*valptr)->value = atoi(value->children->content);
return TRUE;
}
static int schema_restriction_var_char(xmlNodePtr val, sdlRestrictionCharPtr *valptr)
{
xmlAttrPtr fixed, value, id;
if ((*valptr) == NULL) {
(*valptr) = malloc(sizeof(sdlRestrictionChar));
}
memset((*valptr), 0, sizeof(sdlRestrictionChar));
fixed = get_attribute(val->properties, "fixed");
(*valptr)->fixed = FALSE;
if (fixed != NULL) {
if (!strcmp(fixed->children->content, "true") ||
!strcmp(fixed->children->content, "1")) {
(*valptr)->fixed = TRUE;
}
}
id = get_attribute(val->properties, "id");
if (id != NULL) {
(*valptr)->id = strdup(id->children->content);
}
value = get_attribute(val->properties, "value");
if (value == NULL) {
php_error(E_ERROR, "Error parsing wsdl schema \"missing restriction value\"");
}
(*valptr)->value = strdup(value->children->content);
return TRUE;
}
/*
From simpleContent (not supported):
<extension
base = QName
id = ID
{any attributes with non-schema namespace . . .}>
Content: (annotation?, ((attribute | attributeGroup)*, anyAttribute?))
</extension>
*/
static int schema_extension_simpleContent(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr extType, sdlTypePtr cur_type)
{
return TRUE;
}
/*
From complexContent:
<extension
base = QName
id = ID
{any attributes with non-schema namespace . . .}>
Content: (annotation?, ((group | all | choice | sequence)?, ((attribute | attributeGroup)*, anyAttribute?)))
</extension>
*/
static int schema_extension_complexContent(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr extType, sdlTypePtr cur_type)
{
xmlNodePtr content;
xmlAttrPtr base;
base = get_attribute(extType->properties, "base");
content = get_node(extType->children, "group");
if (content != NULL) {
schema_group(sdl, tsn, content, cur_type);
return TRUE;
}
content = get_node(extType->children, "all");
if (content != NULL) {
schema_all(sdl, tsn, content, cur_type);
return TRUE;
}
content = get_node(extType->children, "choice");
if (content != NULL) {
schema_choice(sdl, tsn, content, cur_type);
return TRUE;
}
content = get_node(extType->children, "sequence");
if (content != NULL) {
schema_sequence(sdl, tsn, content, cur_type);
return TRUE;
}
return FALSE;
}
/*
<all
id = ID
maxOccurs = 1 : 1
minOccurs = (0 | 1) : 1
{any attributes with non-schema namespace . . .}>
Content: (annotation?, element*)
</all>
*/
static int schema_all(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr all, sdlTypePtr cur_type)
{
xmlNodePtr element, trav;
trav = all->children;
FOREACHNODE(trav, "element", element) {
schema_element(sdl, tsn, element, cur_type);
}
ENDFOREACH(trav);
return TRUE;
}
/*
<group
name = NCName>
Content: (annotation?, (all | choice | sequence))
</group>
*/
static int schema_group(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr groupType, sdlTypePtr cur_type)
{
xmlNodePtr content;
xmlAttrPtr name;
name = get_attribute(groupType->properties, "name");
if (name != NULL) {
}
content = get_node(groupType->children, "all");
if (content != NULL) {
schema_all(sdl, tsn, content, cur_type);
return TRUE;
}
content = get_node(groupType->children, "choice");
if (content != NULL) {
schema_choice(sdl, tsn, content, cur_type);
return TRUE;
}
content = get_node(groupType->children, "sequence");
if (content != NULL) {
schema_sequence(sdl, tsn, content, cur_type);
return TRUE;
}
return FALSE;
}
/*
<choice
id = ID
maxOccurs = (nonNegativeInteger | unbounded) : 1
minOccurs = nonNegativeInteger : 1
{any attributes with non-schema namespace . . .}>
Content: (annotation?, (element | group | choice | sequence | any)*)
</choice>
*/
static int schema_choice(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr choiceType, sdlTypePtr cur_type)
{
xmlNodePtr trav, data;
/*
cur_type->property_type = CHOICE;
*/
trav = choiceType->children;
FOREACHNODE(trav, "element", data) {
schema_element(sdl, tsn, data, cur_type);
}
ENDFOREACH(trav);
trav = choiceType->children;
FOREACHNODE(trav, "group", data) {
schema_group(sdl, tsn, data, cur_type);
}
ENDFOREACH(trav);
trav = choiceType->children;
FOREACHNODE(trav, "choice", data) {
schema_choice(sdl, tsn, data, cur_type);
}
ENDFOREACH(trav);
trav = choiceType->children;
FOREACHNODE(trav, "sequence", data) {
schema_sequence(sdl, tsn, data, cur_type);
}
ENDFOREACH(trav);
trav = choiceType->children;
FOREACHNODE(trav, "any", data) {
schema_any(sdl, tsn, data, cur_type);
}
ENDFOREACH(trav);
return TRUE;
}
/*
<sequence
id = ID
maxOccurs = (nonNegativeInteger | unbounded) : 1
minOccurs = nonNegativeInteger : 1
{any attributes with non-schema namespace . . .}>
Content: (annotation?, (element | group | choice | sequence | any)*)
</sequence>
*/
static int schema_sequence(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr seqType, sdlTypePtr cur_type)
{
xmlNodePtr trav;
trav = seqType->children;
while (trav != NULL) {
if (trav->type == XML_ELEMENT_NODE) {
if (!strcmp(trav->name, "element")) {
schema_element(sdl, tsn, trav, cur_type);
} else if (!strcmp(trav->name, "group")) {
schema_group(sdl, tsn, trav, cur_type);
} else if (!strcmp(trav->name, "choice")) {
schema_choice(sdl, tsn, trav, cur_type);
} else if (!strcmp(trav->name, "sequence")) {
schema_sequence(sdl, tsn, trav, cur_type);
} else if (!strcmp(trav->name, "any")) {
schema_any(sdl, tsn, trav, cur_type);
}
}
trav = trav->next;
}
return TRUE;
}
static int schema_any(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr extType, sdlTypePtr cur_type)
{
return TRUE;
}
/*
<complexContent
id = ID
mixed = boolean
{any attributes with non-schema namespace . . .}>
Content: (annotation?, (restriction | extension))
</complexContent>
*/
static int schema_complexContent(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr compCont, sdlTypePtr cur_type)
{
xmlNodePtr content;
content = get_node(compCont->children, "restriction");
if (content != NULL) {
schema_restriction_complexContent(sdl, tsn, content, cur_type);
return TRUE;
}
content = get_node(compCont->children, "extension");
if (content != NULL) {
schema_extension_complexContent(sdl, tsn, content, cur_type);
return TRUE;
}
return TRUE;
}
/*
<complexType
abstract = boolean : false
block = (#all | List of (extension | restriction))
final = (#all | List of (extension | restriction))
id = ID
mixed = boolean : false
name = NCName
{any attributes with non-schema namespace . . .}>
Content: (annotation?, (simpleContent | complexContent | ((group | all | choice | sequence)?, ((attribute | attributeGroup)*, anyAttribute?))))
</complexType>
*/
static int schema_complexType(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr compType, sdlTypePtr cur_type)
{
xmlNodePtr content;
xmlAttrPtr attrs, name, ns;
TSRMLS_FETCH();
attrs = compType->properties;
ns = get_attribute(attrs, "targetNamespace");
if (ns == NULL) {
ns = tsn;
}
name = get_attribute(attrs, "name");
if (name) {
HashTable *ht;
sdlTypePtr newType, *ptr;
smart_str key = {0};
newType = malloc(sizeof(sdlType));
memset(newType, 0, sizeof(sdlType));
newType->name = strdup(name->children->content);
newType->namens = strdup(ns->children->content);
if (cur_type == NULL) {
ht = sdl->types;
smart_str_appends(&key, newType->namens);
smart_str_appendc(&key, ':');
smart_str_appends(&key, newType->name);
smart_str_0(&key);
} else {
if (cur_type->elements == NULL) {
cur_type->elements = malloc(sizeof(HashTable));
zend_hash_init(cur_type->elements, 0, NULL, delete_type, 1);
}
ht = cur_type->elements;
smart_str_appends(&key, newType->name);
smart_str_0(&key);
}
zend_hash_update(ht, key.c, key.len + 1, &newType, sizeof(sdlTypePtr), (void **)&ptr);
cur_type = (*ptr);
create_encoder(sdl, cur_type, ns->children->content, name->children->content);
smart_str_free(&key);
if (cur_type->encode == NULL) {
cur_type->encode = get_conversion(SOAP_ENC_OBJECT);
}
}
content = get_node(compType->children, "simpleContent");
if (content != NULL) {
schema_simpleContent(sdl, tsn, content, cur_type);
return TRUE;
}
content = get_node(compType->children, "complexContent");
if (content != NULL) {
schema_complexContent(sdl, tsn, content, cur_type);
return TRUE;
}
/* (group | all | choice | sequence) */
content = get_node(compType->children, "group");
if (content != NULL) {
schema_group(sdl, tsn, content, cur_type);
return TRUE;
}
content = get_node(compType->children, "all");
if (content != NULL) {
schema_all(sdl, tsn, content, cur_type);
return TRUE;
}
content = get_node(compType->children, "choice");
if (content != NULL) {
schema_choice(sdl, tsn, content, cur_type);
return TRUE;
}
content = get_node(compType->children, "sequence");
if (content != NULL) {
schema_sequence(sdl, tsn, content, cur_type);
}
return TRUE;
}
/*
<element
abstract = boolean : false
block = (#all | List of (extension | restriction | substitution))
default = string
final = (#all | List of (extension | restriction))
fixed = string
form = (qualified | unqualified)
id = ID
maxOccurs = (nonNegativeInteger | unbounded) : 1
minOccurs = nonNegativeInteger : 1
name = NCName
nillable = boolean : false
ref = QName
substitutionGroup = QName
type = QName
{any attributes with non-schema namespace . . .}>
Content: (annotation?, ((simpleType | complexType)?, (unique | key | keyref)*))
</element>
*/
static int schema_element(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr element, sdlTypePtr cur_type)
{
xmlNodePtr content;
xmlAttrPtr attrs, curattr, name, ns;
attrs = element->properties;
ns = get_attribute(attrs, "targetNamespace");
if (ns == NULL) {
ns = tsn;
}
name = get_attribute(attrs, "name");
if (!name) {
name = get_attribute(attrs, "ref");
}
if (name) {
HashTable *addHash;
sdlTypePtr newType, *tmp;
smart_str key = {0};
newType = malloc(sizeof(sdlType));
memset(newType, 0, sizeof(sdlType));
newType->name = strdup(name->children->content);
newType->namens = strdup(tsn->children->content);
newType->nillable = FALSE;
newType->min_occurs = 1;
newType->max_occurs = 1;
if (cur_type == NULL) {
addHash = sdl->types;
smart_str_appends(&key, newType->namens);
smart_str_appendc(&key, ':');
smart_str_appends(&key, newType->name);
} else {
if (cur_type->elements == NULL) {
cur_type->elements = malloc(sizeof(HashTable));
zend_hash_init(cur_type->elements, 0, NULL, delete_type, 1);
}
addHash = cur_type->elements;
smart_str_appends(&key, newType->name);
}
smart_str_0(&key);
zend_hash_update(addHash, key.c, key.len + 1, &newType, sizeof(sdlTypePtr), (void **)&tmp);
cur_type = (*tmp);
/*
create_encoder(sdl, cur_type, ns->children->content, name->children->content);
*/
smart_str_free(&key);
}
curattr = get_attribute(attrs, "maxOccurs");
if (curattr) {
if (!strcmp(curattr->children->content, "unbounded")) {
cur_type->max_occurs = -1;
} else {
cur_type->max_occurs = atoi(curattr->children->content);
}
}
curattr = get_attribute(attrs, "minOccurs");
if (curattr) {
cur_type->min_occurs = atoi(curattr->children->content);
}
/* nillable = boolean : false */
attrs = element->properties;
curattr = get_attribute(attrs, "nillable");
if (curattr) {
if (!stricmp(curattr->children->content, "true") ||
!stricmp(curattr->children->content, "1")) {
cur_type->nillable = TRUE;
} else {
cur_type->nillable = FALSE;
}
} else {
cur_type->nillable = FALSE;
}
/* type = QName */
curattr = get_attribute(attrs, "type");
if (!curattr) {
curattr = name;
}
if (curattr) {
char *cptype, *str_ns;
xmlNsPtr nsptr;
parse_namespace(curattr->children->content, &cptype, &str_ns);
/*
if (str_ns) {
*/
nsptr = xmlSearchNs(element->doc, element, str_ns);
/*
} else {
nsptr = xmlSearchNsByHref(element->doc, element, ns->children->content);
}
*/
cur_type->encode = get_create_encoder(sdl, cur_type, (char *)nsptr->href, (char *)cptype);
if (str_ns) {efree(str_ns);}
if (cptype) {efree(cptype);}
}
/*
if (cur_type->max_occurs == -1 || cur_type->max_occurs > 1) {
cur_type->encode = get_conversion(SOAP_ENC_ARRAY);
}
*/
content = get_node(element->children, "simpleType");
if (content) {
schema_simpleType(sdl, tsn, content, cur_type);
}
content = get_node(element->children, "complexType");
if (content) {
schema_complexType(sdl, tsn, content, cur_type);
}
return FALSE;
}
/*
<attribute
default = string
fixed = string
form = (qualified | unqualified)
id = ID
name = NCName
ref = QName
type = QName
use = (optional | prohibited | required) : optional
{any attributes with non-schema namespace . . .}>
Content: (annotation?, (simpleType?))
</attribute>
*/
static int schema_attribute(sdlPtr sdl, xmlAttrPtr tsn, xmlNodePtr attrType, sdlTypePtr cur_type)
{
xmlAttrPtr attr;
sdlAttributePtr newAttr;
xmlAttrPtr trav;
smart_str key = {0};
newAttr = malloc(sizeof(sdlAttribute));
memset(newAttr, 0, sizeof(sdlAttribute));
if (cur_type->attributes == NULL) {
cur_type->attributes = malloc(sizeof(HashTable));
zend_hash_init(cur_type->attributes, 0, NULL, delete_attribute, 1);
}
trav = attrType->properties;
FOREACHATTRNODE(trav, NULL, attr) {
if (attr_is_equal_ex(trav, "default", SCHEMA_NAMESPACE)) {
newAttr->def = strdup(attr->children->content);
} else if (attr_is_equal_ex(trav, "fixed", SCHEMA_NAMESPACE)) {
newAttr->fixed = strdup(attr->children->content);
} else if (attr_is_equal_ex(trav, "form", SCHEMA_NAMESPACE)) {
newAttr->form = strdup(attr->children->content);
} else if (attr_is_equal_ex(trav, "id", SCHEMA_NAMESPACE)) {
newAttr->id = strdup(attr->children->content);
} else if (attr_is_equal_ex(trav, "name", SCHEMA_NAMESPACE)) {
newAttr->name = strdup(attr->children->content);
} else if (attr_is_equal_ex(trav, "ref", SCHEMA_NAMESPACE)) {
newAttr->ref= strdup(attr->children->content);
} else if (attr_is_equal_ex(trav, "type", SCHEMA_NAMESPACE)) {
newAttr->type = strdup(attr->children->content);
} else if (attr_is_equal_ex(trav, "use", SCHEMA_NAMESPACE)) {
newAttr->use = strdup(attr->children->content);
} else {
xmlNsPtr nsPtr = attr_find_ns(trav);
if (strcmp(nsPtr->href, SCHEMA_NAMESPACE)) {
smart_str key2 = {0};
if (!newAttr->extraAttributes) {
newAttr->extraAttributes = malloc(sizeof(HashTable));
zend_hash_init(newAttr->extraAttributes, 0, NULL, NULL, 1);
}
smart_str_appends(&key2, nsPtr->href);
smart_str_appendc(&key2, ':');
smart_str_appends(&key2, trav->name);
smart_str_0(&key2);
zend_hash_add(newAttr->extraAttributes, key2.c, key2.len + 1, &trav, sizeof(xmlAttrPtr), NULL);
smart_str_free(&key2);
}
}
}
ENDFOREACH(trav);
if (newAttr->ref || newAttr->name) {
xmlNsPtr ns;
if (newAttr->ref) {
char *value, *prefix = NULL;
parse_namespace(newAttr->ref, &value, &prefix);
ns = xmlSearchNs(attrType->doc, attrType, prefix);
smart_str_appends(&key, ns->href);
smart_str_appendc(&key, ':');
smart_str_appends(&key, value);
if (value) {efree(value);}
if (prefix) {efree(prefix);}
} else {
ns = node_find_ns(attrType);
smart_str_appends(&key, ns->href);
smart_str_appendc(&key, ':');
smart_str_appends(&key, newAttr->name);
}
if (ns) {
smart_str_0(&key);
zend_hash_add(cur_type->attributes, key.c, key.len + 1, &newAttr, sizeof(sdlAttributePtr), NULL);
smart_str_free(&key);
return TRUE;
}
smart_str_free(&key);
}
zend_hash_next_index_insert(cur_type->attributes, &newAttr, sizeof(sdlAttributePtr), NULL);
return TRUE;
}