Back to index

php5  5.3.10
Functions
php_schema.c File Reference
#include "php_soap.h"
#include "libxml/uri.h"

Go to the source code of this file.

Functions

static int schema_simpleType (sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr simpleType, sdlTypePtr cur_type)
static int schema_complexType (sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr compType, sdlTypePtr cur_type)
static int schema_list (sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr listType, sdlTypePtr cur_type)
static int schema_union (sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr unionType, sdlTypePtr cur_type)
static int schema_simpleContent (sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr simpCompType, sdlTypePtr cur_type)
static int schema_restriction_simpleContent (sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr restType, sdlTypePtr cur_type, int simpleType)
static int schema_restriction_complexContent (sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr restType, sdlTypePtr cur_type)
static int schema_extension_simpleContent (sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr extType, sdlTypePtr cur_type)
static int schema_extension_complexContent (sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr extType, sdlTypePtr cur_type)
static int schema_sequence (sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr seqType, sdlTypePtr cur_type, sdlContentModelPtr model)
static int schema_all (sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr extType, sdlTypePtr cur_type, sdlContentModelPtr model)
static int schema_choice (sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr choiceType, sdlTypePtr cur_type, sdlContentModelPtr model)
static int schema_group (sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr groupType, sdlTypePtr cur_type, sdlContentModelPtr model)
static int schema_any (sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr extType, sdlTypePtr cur_type, sdlContentModelPtr model)
static int schema_element (sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr element, sdlTypePtr cur_type, sdlContentModelPtr model)
static int schema_attribute (sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr attrType, sdlTypePtr cur_type, sdlCtx *ctx)
static int schema_attributeGroup (sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr attrType, sdlTypePtr cur_type, sdlCtx *ctx)
static int schema_restriction_var_int (xmlNodePtr val, sdlRestrictionIntPtr *valptr)
static int schema_restriction_var_char (xmlNodePtr val, sdlRestrictionCharPtr *valptr)
static void schema_type_fixup (sdlCtx *ctx, sdlTypePtr type)
static encodePtr create_encoder (sdlPtr sdl, sdlTypePtr cur_type, const xmlChar *ns, const xmlChar *type)
static encodePtr get_create_encoder (sdlPtr sdl, sdlTypePtr cur_type, const xmlChar *ns, const xmlChar *type)
static void schema_load_file (sdlCtx *ctx, xmlAttrPtr ns, xmlChar *location, xmlAttrPtr tns, int import TSRMLS_DC)
int load_schema (sdlCtx *ctx, xmlNodePtr schema TSRMLS_DC)
void schema_min_max (xmlNodePtr node, sdlContentModelPtr model)
static int schema_complexContent (sdlPtr sdl, xmlAttrPtr tns, xmlNodePtr compCont, sdlTypePtr cur_type)
static void copy_extra_attribute (void *attribute)
static void schema_attribute_fixup (sdlCtx *ctx, sdlAttributePtr attr)
static void schema_attributegroup_fixup (sdlCtx *ctx, sdlAttributePtr attr, HashTable *ht)
static void schema_content_model_fixup (sdlCtx *ctx, sdlContentModelPtr model)
void schema_pass2 (sdlCtx *ctx)
void delete_model (void *handle)
void delete_model_persistent (void *handle)
void delete_type (void *data)
void delete_type_persistent (void *data)
void delete_extra_attribute (void *attribute)
void delete_extra_attribute_persistent (void *attribute)
void delete_attribute (void *attribute)
void delete_attribute_persistent (void *attribute)
void delete_restriction_var_int (void *rvi)
void delete_restriction_var_int_persistent (void *rvi)
void delete_restriction_var_char (void *srvc)
void delete_restriction_var_char_persistent (void *srvc)

Function Documentation

static void copy_extra_attribute ( void *  attribute) [static]

Definition at line 2023 of file php_schema.c.

{
       sdlExtraAttributePtr *attr = (sdlExtraAttributePtr*)attribute;
       sdlExtraAttributePtr new_attr;

       new_attr = emalloc(sizeof(sdlExtraAttribute));
       memcpy(new_attr, *attr, sizeof(sdlExtraAttribute));
       *attr = new_attr;
       if (new_attr->ns) {
              new_attr->ns = estrdup(new_attr->ns);
       }
       if (new_attr->val) {
              new_attr->val = estrdup(new_attr->val);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static encodePtr create_encoder ( sdlPtr  sdl,
sdlTypePtr  cur_type,
const xmlChar *  ns,
const xmlChar *  type 
) [static]

Definition at line 49 of file php_schema.c.

{
       smart_str nscat = {0};
       encodePtr enc, *enc_ptr;

       if (sdl->encoders == NULL) {
              sdl->encoders = emalloc(sizeof(HashTable));
              zend_hash_init(sdl->encoders, 0, NULL, delete_encoder, 0);
       }
       smart_str_appends(&nscat, (char*)ns);
       smart_str_appendc(&nscat, ':');
       smart_str_appends(&nscat, (char*)type);
       smart_str_0(&nscat);
       if (zend_hash_find(sdl->encoders, nscat.c, nscat.len + 1, (void**)&enc_ptr) == SUCCESS) {
              enc = *enc_ptr;
              if (enc->details.ns) {
                     efree(enc->details.ns);
              }
              if (enc->details.type_str) {
                     efree(enc->details.type_str);
              }
       } else {
              enc_ptr = NULL;
              enc = emalloc(sizeof(encode));
       }
       memset(enc, 0, sizeof(encode));

       enc->details.ns = estrdup((char*)ns);
       enc->details.type_str = estrdup((char*)type);
       enc->details.sdl_type = cur_type;
       enc->to_xml = sdl_guess_convert_xml;
       enc->to_zval = sdl_guess_convert_zval;

       if (enc_ptr == NULL) {
              zend_hash_update(sdl->encoders, nscat.c, nscat.len + 1, &enc, sizeof(encodePtr), NULL);
       }
       smart_str_free(&nscat);
       return enc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void delete_attribute ( void *  attribute)

Definition at line 2461 of file php_schema.c.

{
       sdlAttributePtr attr = *((sdlAttributePtr*)attribute);

       if (attr->def) {
              efree(attr->def);
       }
       if (attr->fixed) {
              efree(attr->fixed);
       }
       if (attr->name) {
              efree(attr->name);
       }
       if (attr->namens) {
              efree(attr->namens);
       }
       if (attr->ref) {
              efree(attr->ref);
       }
       if (attr->extraAttributes) {
              zend_hash_destroy(attr->extraAttributes);
              efree(attr->extraAttributes);
       }
       efree(attr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void delete_attribute_persistent ( void *  attribute)

Definition at line 2487 of file php_schema.c.

{
       sdlAttributePtr attr = *((sdlAttributePtr*)attribute);

       if (attr->def) {
              free(attr->def);
       }
       if (attr->fixed) {
              free(attr->fixed);
       }
       if (attr->name) {
              free(attr->name);
       }
       if (attr->namens) {
              free(attr->namens);
       }
       if (attr->ref) {
              free(attr->ref);
       }
       if (attr->extraAttributes) {
              zend_hash_destroy(attr->extraAttributes);
              free(attr->extraAttributes);
       }
       free(attr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void delete_extra_attribute ( void *  attribute)

Definition at line 2435 of file php_schema.c.

{
       sdlExtraAttributePtr attr = *((sdlExtraAttributePtr*)attribute);

       if (attr->ns) {
              efree(attr->ns);
       }
       if (attr->val) {
              efree(attr->val);
       }
       efree(attr);
}

Here is the caller graph for this function:

void delete_extra_attribute_persistent ( void *  attribute)

Definition at line 2448 of file php_schema.c.

{
       sdlExtraAttributePtr attr = *((sdlExtraAttributePtr*)attribute);

       if (attr->ns) {
              free(attr->ns);
       }
       if (attr->val) {
              free(attr->val);
       }
       free(attr);
}

Here is the caller graph for this function:

void delete_model ( void *  handle)

Definition at line 2296 of file php_schema.c.

{
       sdlContentModelPtr tmp = *((sdlContentModelPtr*)handle);
       switch (tmp->kind) {
              case XSD_CONTENT_ELEMENT:
              case XSD_CONTENT_GROUP:
                     break;
              case XSD_CONTENT_SEQUENCE:
              case XSD_CONTENT_ALL:
              case XSD_CONTENT_CHOICE:
                     zend_hash_destroy(tmp->u.content);
                     efree(tmp->u.content);
                     break;
              case XSD_CONTENT_GROUP_REF:
                     efree(tmp->u.group_ref);
                     break;
              default:
                     break;
       }
       efree(tmp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void delete_model_persistent ( void *  handle)

Definition at line 2318 of file php_schema.c.

{
       sdlContentModelPtr tmp = *((sdlContentModelPtr*)handle);
       switch (tmp->kind) {
              case XSD_CONTENT_ELEMENT:
              case XSD_CONTENT_GROUP:
                     break;
              case XSD_CONTENT_SEQUENCE:
              case XSD_CONTENT_ALL:
              case XSD_CONTENT_CHOICE:
                     zend_hash_destroy(tmp->u.content);
                     free(tmp->u.content);
                     break;
              case XSD_CONTENT_GROUP_REF:
                     free(tmp->u.group_ref);
                     break;
              default:
                     break;
       }
       free(tmp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void delete_restriction_var_char ( void *  srvc)

Definition at line 2529 of file php_schema.c.

{
       sdlRestrictionCharPtr ptr = *((sdlRestrictionCharPtr*)srvc);
       if (ptr) {
              if (ptr->value) {
                     efree(ptr->value);
              }
              efree(ptr);
       }
}

Here is the caller graph for this function:

Definition at line 2540 of file php_schema.c.

{
       sdlRestrictionCharPtr ptr = *((sdlRestrictionCharPtr*)srvc);
       if (ptr) {
              if (ptr->value) {
                     free(ptr->value);
              }
              free(ptr);
       }
}

Here is the caller graph for this function:

void delete_restriction_var_int ( void *  rvi)

Definition at line 2513 of file php_schema.c.

{
       sdlRestrictionIntPtr ptr = *((sdlRestrictionIntPtr*)rvi);
       if (ptr) {
              efree(ptr);
       }
}

Here is the caller graph for this function:

Definition at line 2521 of file php_schema.c.

{
       sdlRestrictionIntPtr ptr = *((sdlRestrictionIntPtr*)rvi);
       if (ptr) {
              free(ptr);
       }
}

Here is the caller graph for this function:

void delete_type ( void *  data)

Definition at line 2340 of file php_schema.c.

{
       sdlTypePtr type = *((sdlTypePtr*)data);

       if (type->name) {
              efree(type->name);
       }
       if (type->namens) {
              efree(type->namens);
       }
       if (type->def) {
              efree(type->def);
       }
       if (type->fixed) {
              efree(type->fixed);
       }
       if (type->elements) {
              zend_hash_destroy(type->elements);
              efree(type->elements);
       }
       if (type->attributes) {
              zend_hash_destroy(type->attributes);
              efree(type->attributes);
       }
       if (type->model) {
              delete_model((void**)&type->model);
       }
       if (type->restrictions) {
              delete_restriction_var_int(&type->restrictions->minExclusive);
              delete_restriction_var_int(&type->restrictions->minInclusive);
              delete_restriction_var_int(&type->restrictions->maxExclusive);
              delete_restriction_var_int(&type->restrictions->maxInclusive);
              delete_restriction_var_int(&type->restrictions->totalDigits);
              delete_restriction_var_int(&type->restrictions->fractionDigits);
              delete_restriction_var_int(&type->restrictions->length);
              delete_restriction_var_int(&type->restrictions->minLength);
              delete_restriction_var_int(&type->restrictions->maxLength);
              delete_restriction_var_char(&type->restrictions->whiteSpace);
              delete_restriction_var_char(&type->restrictions->pattern);
              if (type->restrictions->enumeration) {
                     zend_hash_destroy(type->restrictions->enumeration);
                     efree(type->restrictions->enumeration);
              }
              efree(type->restrictions);
       }
       efree(type);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void delete_type_persistent ( void *  data)

Definition at line 2388 of file php_schema.c.

{
       sdlTypePtr type = *((sdlTypePtr*)data);
       if (type->name) {
              free(type->name);
       }
       if (type->namens) {
              free(type->namens);
       }
       if (type->def) {
              free(type->def);
       }
       if (type->fixed) {
              free(type->fixed);
       }
       if (type->elements) {
              zend_hash_destroy(type->elements);
              free(type->elements);
       }
       if (type->attributes) {
              zend_hash_destroy(type->attributes);
              free(type->attributes);
       }
       if (type->model) {
              delete_model_persistent((void**)&type->model);
       }
       if (type->restrictions) {
              delete_restriction_var_int_persistent(&type->restrictions->minExclusive);
              delete_restriction_var_int_persistent(&type->restrictions->minInclusive);
              delete_restriction_var_int_persistent(&type->restrictions->maxExclusive);
              delete_restriction_var_int_persistent(&type->restrictions->maxInclusive);
              delete_restriction_var_int_persistent(&type->restrictions->totalDigits);
              delete_restriction_var_int_persistent(&type->restrictions->fractionDigits);
              delete_restriction_var_int_persistent(&type->restrictions->length);
              delete_restriction_var_int_persistent(&type->restrictions->minLength);
              delete_restriction_var_int_persistent(&type->restrictions->maxLength);
              delete_restriction_var_char_persistent(&type->restrictions->whiteSpace);
              delete_restriction_var_char_persistent(&type->restrictions->pattern);
              if (type->restrictions->enumeration) {
                     zend_hash_destroy(type->restrictions->enumeration);
                     free(type->restrictions->enumeration);
              }
              free(type->restrictions);
       }
       free(type);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static encodePtr get_create_encoder ( sdlPtr  sdl,
sdlTypePtr  cur_type,
const xmlChar *  ns,
const xmlChar *  type 
) [static]

Definition at line 89 of file php_schema.c.

{
       encodePtr enc = get_encoder(sdl, (char*)ns, (char*)type);
       if (enc == NULL) {
              enc = create_encoder(sdl, cur_type, ns, type);
       }
       return enc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int load_schema ( sdlCtx ctx,
xmlNodePtr schema  TSRMLS_DC 
)

Definition at line 163 of file php_schema.c.

{
       xmlNodePtr trav;
       xmlAttrPtr tns;

       if (!ctx->sdl->types) {
              ctx->sdl->types = emalloc(sizeof(HashTable));
              zend_hash_init(ctx->sdl->types, 0, NULL, delete_type, 0);
       }
       if (!ctx->attributes) {
              ctx->attributes = emalloc(sizeof(HashTable));
              zend_hash_init(ctx->attributes, 0, NULL, delete_attribute, 0);
       }
       if (!ctx->attributeGroups) {
              ctx->attributeGroups = emalloc(sizeof(HashTable));
              zend_hash_init(ctx->attributeGroups, 0, NULL, delete_type, 0);
       }

       tns = get_attribute(schema->properties, "targetNamespace");
       if (tns == NULL) {
              tns = xmlSetProp(schema, BAD_CAST("targetNamespace"), BAD_CAST(""));
              xmlNewNs(schema, BAD_CAST(""), NULL);
       }

       trav = schema->children;
       while (trav != NULL) {
              if (node_is_equal(trav,"include")) {
                     xmlAttrPtr location;

                     location = get_attribute(trav->properties, "schemaLocation");
                     if (location == NULL) {
                            soap_error0(E_ERROR, "Parsing Schema: include has no 'schemaLocation' attribute");
                     } else {
                            xmlChar *uri;
                            xmlChar *base = xmlNodeGetBase(trav->doc, trav);

                            if (base == NULL) {
                         uri = xmlBuildURI(location->children->content, trav->doc->URL);
                            } else {
                     uri = xmlBuildURI(location->children->content, base);
                         xmlFree(base);
                            }
                            schema_load_file(ctx, NULL, uri, tns, 0 TSRMLS_CC);
                            xmlFree(uri);
                     }

              } else if (node_is_equal(trav,"redefine")) {
                     xmlAttrPtr location;

                     location = get_attribute(trav->properties, "schemaLocation");
                     if (location == NULL) {
                            soap_error0(E_ERROR, "Parsing Schema: redefine has no 'schemaLocation' attribute");
                     } else {
                       xmlChar *uri;
                            xmlChar *base = xmlNodeGetBase(trav->doc, trav);

                            if (base == NULL) {
                         uri = xmlBuildURI(location->children->content, trav->doc->URL);
                            } else {
                     uri = xmlBuildURI(location->children->content, base);
                         xmlFree(base);
                            }
                            schema_load_file(ctx, NULL, uri, tns, 0 TSRMLS_CC);
                            xmlFree(uri);
                            /* TODO: <redefine> support */
                     }

              } else if (node_is_equal(trav,"import")) {
                     xmlAttrPtr ns, location;
                     xmlChar *uri = NULL;

                     ns = get_attribute(trav->properties, "namespace");
                     location = get_attribute(trav->properties, "schemaLocation");

                     if (ns != NULL && tns != NULL && xmlStrcmp(ns->children->content, tns->children->content) == 0) {
                            if (location) {
                                   soap_error1(E_ERROR, "Parsing Schema: can't import schema from '%s', namespace must not match the enclosing schema 'targetNamespace'", location->children->content);
                            } else {
                                   soap_error0(E_ERROR, "Parsing Schema: can't import schema. Namespace must not match the enclosing schema 'targetNamespace'");
                            }
                     }
                     if (location) {
                            xmlChar *base = xmlNodeGetBase(trav->doc, trav);

                            if (base == NULL) {
                         uri = xmlBuildURI(location->children->content, trav->doc->URL);
                            } else {
                     uri = xmlBuildURI(location->children->content, base);
                         xmlFree(base);
                            }
                     }
                     schema_load_file(ctx, ns, uri, tns, 1 TSRMLS_CC);
                     if (uri != NULL) {xmlFree(uri);}
              } else if (node_is_equal(trav,"annotation")) {
                     /* TODO: <annotation> support */
/* annotation cleanup
                     xmlNodePtr tmp = trav;
                     trav = trav->next;
                     xmlUnlinkNode(tmp);
                     xmlFreeNode(tmp);
                     continue;
*/
              } else {
                     break;
              }
              trav = trav->next;
       }

       while (trav != NULL) {
              if (node_is_equal(trav,"simpleType")) {
                     schema_simpleType(ctx->sdl, tns, trav, NULL);
              } else if (node_is_equal(trav,"complexType")) {
                     schema_complexType(ctx->sdl, tns, trav, NULL);
              } else if (node_is_equal(trav,"group")) {
                     schema_group(ctx->sdl, tns, trav, NULL, NULL);
              } else if (node_is_equal(trav,"attributeGroup")) {
                     schema_attributeGroup(ctx->sdl, tns, trav, NULL, ctx);
              } else if (node_is_equal(trav,"element")) {
                     schema_element(ctx->sdl, tns, trav, NULL, NULL);
              } else if (node_is_equal(trav,"attribute")) {
                     schema_attribute(ctx->sdl, tns, trav, NULL, ctx);
              } else if (node_is_equal(trav,"notation")) {
                     /* TODO: <notation> support */
              } else if (node_is_equal(trav,"annotation")) {
                     /* TODO: <annotation> support */
              } else {
                     soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in schema", trav->name);
              }
              trav = trav->next;
       }
       return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int schema_all ( sdlPtr  sdl,
xmlAttrPtr  tns,
xmlNodePtr  extType,
sdlTypePtr  cur_type,
sdlContentModelPtr  model 
) [static]

Definition at line 1013 of file php_schema.c.

{
       xmlNodePtr trav;
       sdlContentModelPtr newModel;

       newModel = emalloc(sizeof(sdlContentModel));
       newModel->kind = XSD_CONTENT_ALL;
       newModel->u.content = emalloc(sizeof(HashTable));
       zend_hash_init(newModel->u.content, 0, NULL, delete_model, 0);
       if (model == NULL) {
              cur_type->model = newModel;
       } else {
              zend_hash_next_index_insert(model->u.content,&newModel,sizeof(sdlContentModelPtr), NULL);
       }

       schema_min_max(all, newModel);

       trav = all->children;
       if (trav != NULL && node_is_equal(trav,"annotation")) {
              /* TODO: <annotation> support */
              trav = trav->next;
       }
       while (trav != NULL) {
              if (node_is_equal(trav,"element")) {
                     schema_element(sdl, tns, trav, cur_type, newModel);
              } else {
                     soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in all", trav->name);
              }
              trav = trav->next;
       }
       return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int schema_any ( sdlPtr  sdl,
xmlAttrPtr  tns,
xmlNodePtr  extType,
sdlTypePtr  cur_type,
sdlContentModelPtr  model 
) [static]

Definition at line 1283 of file php_schema.c.

{
       if (model != NULL) {
              sdlContentModelPtr newModel;

              newModel = emalloc(sizeof(sdlContentModel));
              newModel->kind = XSD_CONTENT_ANY;

              schema_min_max(anyType, newModel);

              zend_hash_next_index_insert(model->u.content, &newModel, sizeof(sdlContentModelPtr), NULL);
       }
       return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int schema_attribute ( sdlPtr  sdl,
xmlAttrPtr  tns,
xmlNodePtr  attrType,
sdlTypePtr  cur_type,
sdlCtx ctx 
) [static]

Definition at line 1712 of file php_schema.c.

{
       sdlAttributePtr newAttr;
       xmlAttrPtr attr, name, ref = NULL, type = NULL;
       xmlNodePtr trav;

       name = get_attribute(attrType->properties, "name");
       if (name == NULL) {
              name = ref = get_attribute(attrType->properties, "ref");
       }
       if (name) {
              HashTable *addHash;
              smart_str key = {0};

              newAttr = emalloc(sizeof(sdlAttribute));
              memset(newAttr, 0, sizeof(sdlAttribute));

              if (ref) {
                     char *attr_name, *ns;
                     xmlNsPtr nsptr;

                     parse_namespace(ref->children->content, &attr_name, &ns);
                     nsptr = xmlSearchNs(attrType->doc, attrType, BAD_CAST(ns));
                     if (nsptr != NULL) {
                            smart_str_appends(&key, (char*)nsptr->href);
                            newAttr->namens = estrdup((char*)nsptr->href);
                     }
                     smart_str_appendc(&key, ':');
                     smart_str_appends(&key, attr_name);
                     smart_str_0(&key);
                     newAttr->ref = estrdup(key.c);
                     if (attr_name) {efree(attr_name);}
                     if (ns) {efree(ns);}
              } else {
                     xmlAttrPtr ns;

                     ns = get_attribute(attrType->properties, "targetNamespace");
                     if (ns == NULL) {
                            ns = tns;
                     }
                     if (ns != NULL) {
                            smart_str_appends(&key, (char*)ns->children->content);
                            smart_str_appendc(&key, ':');
                            newAttr->namens = estrdup((char*)ns->children->content);
                     }
                     smart_str_appends(&key, (char*)name->children->content);
                     smart_str_0(&key);
              }

              if (cur_type == NULL) {
                     addHash = ctx->attributes;
              } else {
                     if (cur_type->attributes == NULL) {
                            cur_type->attributes = emalloc(sizeof(HashTable));
                            zend_hash_init(cur_type->attributes, 0, NULL, delete_attribute, 0);
                     }
                     addHash = cur_type->attributes;
              }

              if (zend_hash_add(addHash, key.c, key.len + 1, &newAttr, sizeof(sdlAttributePtr), NULL) != SUCCESS) {
                     soap_error1(E_ERROR, "Parsing Schema: attribute '%s' already defined", key.c);
              }
              smart_str_free(&key);
       } else{
              soap_error0(E_ERROR, "Parsing Schema: attribute has no 'name' nor 'ref' attributes");
       }

       /* type = QName */
       type = get_attribute(attrType->properties, "type");
       if (type) {
              char *cptype, *str_ns;
              xmlNsPtr nsptr;

              if (ref != NULL) {
                     soap_error0(E_ERROR, "Parsing Schema: attribute has both 'ref' and 'type' attributes");
              }
              parse_namespace(type->children->content, &cptype, &str_ns);
              nsptr = xmlSearchNs(attrType->doc, attrType, BAD_CAST(str_ns));
              if (nsptr != NULL) {
                     newAttr->encode = get_create_encoder(sdl, cur_type, nsptr->href, BAD_CAST(cptype));
              }
              if (str_ns) {efree(str_ns);}
              if (cptype) {efree(cptype);}
       }

       attr = attrType->properties;
       while (attr != NULL) {
              if (attr_is_equal_ex(attr, "default", SCHEMA_NAMESPACE)) {
                     newAttr->def = estrdup((char*)attr->children->content);
              } else if (attr_is_equal_ex(attr, "fixed", SCHEMA_NAMESPACE)) {
                     newAttr->fixed = estrdup((char*)attr->children->content);
              } else if (attr_is_equal_ex(attr, "form", SCHEMA_NAMESPACE)) {
                     if (strncmp((char*)attr->children->content, "qualified", sizeof("qualified")) == 0) {
                       newAttr->form = XSD_FORM_QUALIFIED;
                     } else if (strncmp((char*)attr->children->content, "unqualified", sizeof("unqualified")) == 0) {
                       newAttr->form = XSD_FORM_UNQUALIFIED;
                     } else {
                       newAttr->form = XSD_FORM_DEFAULT;
                     }
              } else if (attr_is_equal_ex(attr, "id", SCHEMA_NAMESPACE)) {
                     /* skip */
              } else if (attr_is_equal_ex(attr, "name", SCHEMA_NAMESPACE)) {
                     newAttr->name = estrdup((char*)attr->children->content);
              } else if (attr_is_equal_ex(attr, "ref", SCHEMA_NAMESPACE)) {
                     /* already processed */
              } else if (attr_is_equal_ex(attr, "type", SCHEMA_NAMESPACE)) {
                     /* already processed */
              } else if (attr_is_equal_ex(attr, "use", SCHEMA_NAMESPACE)) {
                     if (strncmp((char*)attr->children->content, "prohibited", sizeof("prohibited")) == 0) {
                       newAttr->use = XSD_USE_PROHIBITED;
                     } else if (strncmp((char*)attr->children->content, "required", sizeof("required")) == 0) {
                       newAttr->use = XSD_USE_REQUIRED;
                     } else if (strncmp((char*)attr->children->content, "optional", sizeof("optional")) == 0) {
                       newAttr->use = XSD_USE_OPTIONAL;
                     } else {
                       newAttr->use = XSD_USE_DEFAULT;
                     }
              } else {
                     xmlNsPtr nsPtr = attr_find_ns(attr);

                     if (strncmp((char*)nsPtr->href, SCHEMA_NAMESPACE, sizeof(SCHEMA_NAMESPACE))) {
                            smart_str key2 = {0};
                            sdlExtraAttributePtr ext;
                            xmlNsPtr nsptr;
                            char *value, *ns;

                            ext = emalloc(sizeof(sdlExtraAttribute));
                            memset(ext, 0, sizeof(sdlExtraAttribute));
                            parse_namespace(attr->children->content, &value, &ns);
                            nsptr = xmlSearchNs(attr->doc, attr->parent, BAD_CAST(ns));
                            if (nsptr) {
                                   ext->ns = estrdup((char*)nsptr->href);
                                   ext->val = estrdup(value);
                            } else {
                                   ext->val = estrdup((char*)attr->children->content);
                            }
                            if (ns) {efree(ns);}
                            efree(value);

                            if (!newAttr->extraAttributes) {
                                   newAttr->extraAttributes = emalloc(sizeof(HashTable));
                                   zend_hash_init(newAttr->extraAttributes, 0, NULL, delete_extra_attribute, 0);
                            }

                            smart_str_appends(&key2, (char*)nsPtr->href);
                            smart_str_appendc(&key2, ':');
                            smart_str_appends(&key2, (char*)attr->name);
                            smart_str_0(&key2);
                            zend_hash_add(newAttr->extraAttributes, key2.c, key2.len + 1, &ext, sizeof(sdlExtraAttributePtr), NULL);
                            smart_str_free(&key2);
                     }
              }
              attr = attr->next;
       }
       if (newAttr->form == XSD_FORM_DEFAULT) {
              xmlNodePtr parent = attrType->parent;
              while (parent) {
                     if (node_is_equal_ex(parent, "schema", SCHEMA_NAMESPACE)) {
                            xmlAttrPtr def;
                            def = get_attribute(parent->properties, "attributeFormDefault");
                            if(def == NULL || strncmp((char*)def->children->content, "qualified", sizeof("qualified"))) {
                                   newAttr->form = XSD_FORM_UNQUALIFIED;
                            } else {
                                   newAttr->form = XSD_FORM_QUALIFIED;
                            }
                            break;
                     }
                     parent = parent->parent;
       }
              if (parent == NULL) {
                     newAttr->form = XSD_FORM_UNQUALIFIED;
              }      
       }
       trav = attrType->children;
       if (trav != NULL && node_is_equal(trav, "annotation")) {
              /* TODO: <annotation> support */
              trav = trav->next;
       }
       if (trav != NULL) {
              if (node_is_equal(trav,"simpleType")) {
                     sdlTypePtr dummy_type;
                     if (ref != NULL) {
                            soap_error0(E_ERROR, "Parsing Schema: attribute has both 'ref' attribute and subtype");
                     } else if (type != NULL) {
                            soap_error0(E_ERROR, "Parsing Schema: attribute has both 'type' attribute and subtype");
                     }
                     dummy_type = emalloc(sizeof(sdlType));
                     memset(dummy_type, 0, sizeof(sdlType));
                     {
                            smart_str anonymous = {0};
                     
                            smart_str_appendl(&anonymous, "anonymous", sizeof("anonymous")-1);
                            smart_str_append_long(&anonymous, zend_hash_num_elements(sdl->types));
                            smart_str_0(&anonymous);
                            dummy_type->name = anonymous.c;
                     }
                     dummy_type->namens = estrdup((char*)tns->children->content);
                     schema_simpleType(sdl, tns, trav, dummy_type);
                     newAttr->encode = dummy_type->encode;
                     delete_type(&dummy_type);
                     trav = trav->next;
              }
       }
       if (trav != NULL) {
              soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in attribute", trav->name);
       }
       return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void schema_attribute_fixup ( sdlCtx ctx,
sdlAttributePtr  attr 
) [static]

Definition at line 2039 of file php_schema.c.

{
       sdlAttributePtr *tmp;

       if (attr->ref != NULL) {
              if (ctx->attributes != NULL) {
                     if (zend_hash_find(ctx->attributes, attr->ref, strlen(attr->ref)+1, (void**)&tmp) == SUCCESS) {
                            schema_attribute_fixup(ctx, *tmp);
                            if ((*tmp)->name != NULL && attr->name == NULL) {
                                   attr->name = estrdup((*tmp)->name);
                            }
                            if ((*tmp)->namens != NULL && attr->namens == NULL) {
                                   attr->namens = estrdup((*tmp)->namens);
                            }
                            if ((*tmp)->def != NULL && attr->def == NULL) {
                                   attr->def = estrdup((*tmp)->def);
                            }
                            if ((*tmp)->fixed != NULL && attr->fixed == NULL) {
                                   attr->fixed = estrdup((*tmp)->fixed);
                            }
                            if (attr->form == XSD_FORM_DEFAULT) {
                                   attr->form = (*tmp)->form;
                            }
                            if (attr->use == XSD_USE_DEFAULT) {
                                   attr->use  = (*tmp)->use;
                            }
                            if ((*tmp)->extraAttributes != NULL) {
                              xmlNodePtr node;

                                   attr->extraAttributes = emalloc(sizeof(HashTable));
                                   zend_hash_init(attr->extraAttributes, zend_hash_num_elements((*tmp)->extraAttributes), NULL, delete_extra_attribute, 0);
                                   zend_hash_copy(attr->extraAttributes, (*tmp)->extraAttributes, copy_extra_attribute, &node, sizeof(xmlNodePtr));
                            }
                            attr->encode = (*tmp)->encode;
                     }
              }
              if (attr->name == NULL && attr->ref != NULL) {
                     char *name = strrchr(attr->ref, ':');
                     if (name) {
                            attr->name = estrdup(name+1);
                     } else{
                            attr->name = estrdup(attr->ref);
                     }
              }
              efree(attr->ref);
              attr->ref = NULL;
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int schema_attributeGroup ( sdlPtr  sdl,
xmlAttrPtr  tns,
xmlNodePtr  attrType,
sdlTypePtr  cur_type,
sdlCtx ctx 
) [static]

Definition at line 1921 of file php_schema.c.

{
       xmlNodePtr trav;
       xmlAttrPtr name, ref = NULL;


       name = get_attribute(attrGroup->properties, "name");
       if (name == NULL) {
              name = ref = get_attribute(attrGroup->properties, "ref");
       }
       if (name) {
              if (cur_type == NULL) {
                     xmlAttrPtr ns;
                     sdlTypePtr newType;
                     smart_str key = {0};

                     ns = get_attribute(attrGroup->properties, "targetNamespace");
                     if (ns == NULL) {
                            ns = tns;
                     }
                     newType = emalloc(sizeof(sdlType));
                     memset(newType, 0, sizeof(sdlType));
                     newType->name = estrdup((char*)name->children->content);
                     newType->namens = estrdup((char*)ns->children->content);

                     smart_str_appends(&key, newType->namens);
                     smart_str_appendc(&key, ':');
                     smart_str_appends(&key, newType->name);
                     smart_str_0(&key);

                     if (zend_hash_add(ctx->attributeGroups, key.c, key.len + 1, &newType, sizeof(sdlTypePtr), NULL) != SUCCESS) {
                            soap_error1(E_ERROR, "Parsing Schema: attributeGroup '%s' already defined", key.c);
                     }
                     cur_type = newType;
                     smart_str_free(&key);
              } else if (ref) {
                     sdlAttributePtr newAttr;
                     char *group_name, *ns;
                     smart_str key = {0};
                     xmlNsPtr nsptr;

                     if (cur_type->attributes == NULL) {
                            cur_type->attributes = emalloc(sizeof(HashTable));
                            zend_hash_init(cur_type->attributes, 0, NULL, delete_attribute, 0);
                     }
                     newAttr = emalloc(sizeof(sdlAttribute));
                     memset(newAttr, 0, sizeof(sdlAttribute));

                     parse_namespace(ref->children->content, &group_name, &ns);
                     nsptr = xmlSearchNs(attrGroup->doc, attrGroup, BAD_CAST(ns));
                     if (nsptr != NULL) {
                            smart_str_appends(&key, (char*)nsptr->href);
                     }
                     smart_str_appendc(&key, ':');
                     smart_str_appends(&key, group_name);
                     smart_str_0(&key);
                     newAttr->ref = estrdup(key.c);
                     if (group_name) {efree(group_name);}
                     if (ns) {efree(ns);}
                     smart_str_free(&key);

                     zend_hash_next_index_insert(cur_type->attributes, &newAttr, sizeof(sdlAttributePtr), NULL);
                     cur_type = NULL;
              }
       } else{
              soap_error0(E_ERROR, "Parsing Schema: attributeGroup has no 'name' nor 'ref' attributes");
       }

       trav = attrGroup->children;
       if (trav != NULL && node_is_equal(trav, "annotation")) {
              /* TODO: <annotation> support */
              trav = trav->next;
       }
       while (trav != NULL) {
              if (node_is_equal(trav,"attribute")) {
                     if (ref != NULL) {
                            soap_error0(E_ERROR, "Parsing Schema: attributeGroup has both 'ref' attribute and subattribute");
                     }
                     schema_attribute(sdl, tns, trav, cur_type, NULL);
              } else if (node_is_equal(trav,"attributeGroup")) {
                     if (ref != NULL) {
                            soap_error0(E_ERROR, "Parsing Schema: attributeGroup has both 'ref' attribute and subattribute");
                     }
                     schema_attributeGroup(sdl, tns, trav, cur_type, NULL);
              } else if (node_is_equal(trav,"anyAttribute")) {
                     if (ref != NULL) {
                            soap_error0(E_ERROR, "Parsing Schema: attributeGroup has both 'ref' attribute and subattribute");
                     }
                     /* TODO: <anyAttribute> support */
                     trav = trav->next;
                     break;
              } else {
                     soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in attributeGroup", trav->name);
              }
              trav = trav->next;
       }
       if (trav != NULL) {
              soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in attributeGroup", trav->name);
       }
       return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void schema_attributegroup_fixup ( sdlCtx ctx,
sdlAttributePtr  attr,
HashTable ht 
) [static]

Definition at line 2088 of file php_schema.c.

{
       sdlTypePtr *tmp;
       sdlAttributePtr *tmp_attr;

       if (attr->ref != NULL) {
              if (ctx->attributeGroups != NULL) {
                     if (zend_hash_find(ctx->attributeGroups, attr->ref, strlen(attr->ref)+1, (void**)&tmp) == SUCCESS) {
                            if ((*tmp)->attributes) {
                                   zend_hash_internal_pointer_reset((*tmp)->attributes);
                                   while (zend_hash_get_current_data((*tmp)->attributes,(void**)&tmp_attr) == SUCCESS) {
                                          if (zend_hash_get_current_key_type((*tmp)->attributes) == HASH_KEY_IS_STRING) {
                                                 char* key;
                                                 uint key_len;
                                                 sdlAttributePtr newAttr;

                                                 schema_attribute_fixup(ctx,*tmp_attr);

                                                 newAttr = emalloc(sizeof(sdlAttribute));
                                                 memcpy(newAttr, *tmp_attr, sizeof(sdlAttribute));
                                                 if (newAttr->def) {newAttr->def = estrdup(newAttr->def);}
                                                 if (newAttr->fixed) {newAttr->fixed = estrdup(newAttr->fixed);}
                                                 if (newAttr->namens) {newAttr->namens = estrdup(newAttr->namens);}
                                                 if (newAttr->name) {newAttr->name = estrdup(newAttr->name);}
                                                 if (newAttr->extraAttributes) {
                                                   xmlNodePtr node;
                                                        HashTable *ht = emalloc(sizeof(HashTable));
                                                        zend_hash_init(ht, zend_hash_num_elements(newAttr->extraAttributes), NULL, delete_extra_attribute, 0);
                                                        zend_hash_copy(ht, newAttr->extraAttributes, copy_extra_attribute, &node, sizeof(xmlNodePtr));
                                                        newAttr->extraAttributes = ht;
                                                 }

                                                 zend_hash_get_current_key_ex((*tmp)->attributes, &key, &key_len, NULL, 0, NULL);
                                                 zend_hash_add(ht, key, key_len, &newAttr, sizeof(sdlAttributePtr), NULL);

                                                 zend_hash_move_forward((*tmp)->attributes);
                                          } else {
                                                 ulong index;

                                                 schema_attributegroup_fixup(ctx,*tmp_attr, ht);
                                                 zend_hash_get_current_key((*tmp)->attributes, NULL, &index, 0);
                                                 zend_hash_index_del((*tmp)->attributes, index);
                                          }
                                   }
                            }
                     }
              }
              efree(attr->ref);
              attr->ref = NULL;
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int schema_choice ( sdlPtr  sdl,
xmlAttrPtr  tns,
xmlNodePtr  choiceType,
sdlTypePtr  cur_type,
sdlContentModelPtr  model 
) [static]

Definition at line 1181 of file php_schema.c.

{
       xmlNodePtr trav;
       sdlContentModelPtr newModel;

       newModel = emalloc(sizeof(sdlContentModel));
       newModel->kind = XSD_CONTENT_CHOICE;
       newModel->u.content = emalloc(sizeof(HashTable));
       zend_hash_init(newModel->u.content, 0, NULL, delete_model, 0);
       if (model == NULL) {
              cur_type->model = newModel;
       } else {
              zend_hash_next_index_insert(model->u.content,&newModel,sizeof(sdlContentModelPtr), NULL);
       }

       schema_min_max(choiceType, newModel);

       trav = choiceType->children;
       if (trav != NULL && node_is_equal(trav,"annotation")) {
              /* TODO: <annotation> support */
              trav = trav->next;
       }
       while (trav != NULL) {
              if (node_is_equal(trav,"element")) {
                     schema_element(sdl, tns, trav, cur_type, newModel);
              } else if (node_is_equal(trav,"group")) {
                     schema_group(sdl, tns, trav, cur_type, newModel);
              } else if (node_is_equal(trav,"choice")) {
                     schema_choice(sdl, tns, trav, cur_type, newModel);
              } else if (node_is_equal(trav,"sequence")) {
                     schema_sequence(sdl, tns, trav, cur_type, newModel);
              } else if (node_is_equal(trav,"any")) {
                     schema_any(sdl, tns, trav, cur_type, newModel);
              } else {
                     soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in choice", trav->name);
              }
              trav = trav->next;
       }
       return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int schema_complexContent ( sdlPtr  sdl,
xmlAttrPtr  tns,
xmlNodePtr  compCont,
sdlTypePtr  cur_type 
) [static]

Definition at line 1306 of file php_schema.c.

{
       xmlNodePtr trav;

       trav = compCont->children;
       if (trav != NULL && node_is_equal(trav,"annotation")) {
              /* TODO: <annotation> support */
              trav = trav->next;
       }
       if (trav != NULL) {
              if (node_is_equal(trav, "restriction")) {
                     cur_type->kind = XSD_TYPEKIND_RESTRICTION;
                     schema_restriction_complexContent(sdl, tns, trav, cur_type);
                     trav = trav->next;
              } else if (node_is_equal(trav, "extension")) {
                     cur_type->kind = XSD_TYPEKIND_EXTENSION;
                     schema_extension_complexContent(sdl, tns, trav, cur_type);
                     trav = trav->next;
              } else {
                     soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in complexContent", trav->name);
              }
       } else {
              soap_error0(E_ERROR, "Parsing Schema: <restriction> or <extension> expected in complexContent");
       }
       if (trav != NULL) {
              soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in complexContent", trav->name);
       }

       return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int schema_complexType ( sdlPtr  sdl,
xmlAttrPtr  tns,
xmlNodePtr  compType,
sdlTypePtr  cur_type 
) [static]

Definition at line 1349 of file php_schema.c.

{
       xmlNodePtr trav;
       xmlAttrPtr attrs, name, ns;

       attrs = compType->properties;
       ns = get_attribute(attrs, "targetNamespace");
       if (ns == NULL) {
              ns = tns;
       }

       name = get_attribute(attrs, "name");
       if (cur_type != NULL) {
              /* Anonymous type inside <element> */
              sdlTypePtr newType, *ptr;

              newType = emalloc(sizeof(sdlType));
              memset(newType, 0, sizeof(sdlType));
              newType->kind = XSD_TYPEKIND_COMPLEX;
              if (name != NULL) {
                     newType->name = estrdup((char*)name->children->content);
                     newType->namens = estrdup((char*)ns->children->content);
              } else {
                     newType->name = estrdup(cur_type->name);
                     newType->namens = estrdup(cur_type->namens);
              }

              zend_hash_next_index_insert(sdl->types,  &newType, sizeof(sdlTypePtr), (void **)&ptr);

              if (sdl->encoders == NULL) {
                     sdl->encoders = emalloc(sizeof(HashTable));
                     zend_hash_init(sdl->encoders, 0, NULL, delete_encoder, 0);
              }
              cur_type->encode = emalloc(sizeof(encode));
              memset(cur_type->encode, 0, sizeof(encode));
              cur_type->encode->details.ns = estrdup(newType->namens);
              cur_type->encode->details.type_str = estrdup(newType->name);
              cur_type->encode->details.sdl_type = *ptr;
              cur_type->encode->to_xml = sdl_guess_convert_xml;
              cur_type->encode->to_zval = sdl_guess_convert_zval;
              zend_hash_next_index_insert(sdl->encoders,  &cur_type->encode, sizeof(encodePtr), NULL);

              cur_type =*ptr;

       } else if (name) {
              sdlTypePtr newType, *ptr;

              newType = emalloc(sizeof(sdlType));
              memset(newType, 0, sizeof(sdlType));
              newType->kind = XSD_TYPEKIND_COMPLEX;
              newType->name = estrdup((char*)name->children->content);
              newType->namens = estrdup((char*)ns->children->content);

              zend_hash_next_index_insert(sdl->types,  &newType, sizeof(sdlTypePtr), (void **)&ptr);

              cur_type = (*ptr);
              create_encoder(sdl, cur_type, ns->children->content, name->children->content);
       } else {
              soap_error0(E_ERROR, "Parsing Schema: complexType has no 'name' attribute");
              return FALSE;
       }

       trav = compType->children;
       if (trav != NULL && node_is_equal(trav, "annotation")) {
              /* TODO: <annotation> support */
              trav = trav->next;
       }
       if (trav != NULL) {
              if (node_is_equal(trav,"simpleContent")) {
                     schema_simpleContent(sdl, tns, trav, cur_type);
                     trav = trav->next;
              } else if (node_is_equal(trav,"complexContent")) {
                     schema_complexContent(sdl, tns, trav, cur_type);
                     trav = trav->next;
              } else {
                     if (node_is_equal(trav,"group")) {
                            schema_group(sdl, tns, trav, cur_type, NULL);
                            trav = trav->next;
                     } else if (node_is_equal(trav,"all")) {
                            schema_all(sdl, tns, trav, cur_type, NULL);
                            trav = trav->next;
                     } else if (node_is_equal(trav,"choice")) {
                            schema_choice(sdl, tns, trav, cur_type, NULL);
                            trav = trav->next;
                     } else if (node_is_equal(trav,"sequence")) {
                            schema_sequence(sdl, tns, trav, cur_type, NULL);
                            trav = trav->next;
                     }
                     while (trav != NULL) {
                            if (node_is_equal(trav,"attribute")) {
                                   schema_attribute(sdl, tns, trav, cur_type, NULL);
                            } else if (node_is_equal(trav,"attributeGroup")) {
                                   schema_attributeGroup(sdl, tns, trav, cur_type, NULL);
                            } else if (node_is_equal(trav,"anyAttribute")) {
                                   /* TODO: <anyAttribute> support */
                                   trav = trav->next;
                                   break;
                            } else {
                                   soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in complexType", trav->name);
                            }
                            trav = trav->next;
                     }
              }
       }
       if (trav != NULL) {
              soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in complexType", trav->name);
       }
       return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void schema_content_model_fixup ( sdlCtx ctx,
sdlContentModelPtr  model 
) [static]

Definition at line 2140 of file php_schema.c.

{
       switch (model->kind) {
              case XSD_CONTENT_GROUP_REF: {
                     sdlTypePtr *tmp;

                     if (ctx->sdl->groups && zend_hash_find(ctx->sdl->groups, model->u.group_ref, strlen(model->u.group_ref)+1, (void**)&tmp) == SUCCESS) {
                            schema_type_fixup(ctx,*tmp);
                            efree(model->u.group_ref);
                            model->kind = XSD_CONTENT_GROUP;
                            model->u.group = (*tmp);
                     } else {
                            soap_error0(E_ERROR, "Parsing Schema: unresolved group 'ref' attribute");
                     }
                     break;
              }
              case XSD_CONTENT_CHOICE: {
                     if (model->max_occurs != 1) {
                            HashPosition pos;
                            sdlContentModelPtr *tmp;

                            zend_hash_internal_pointer_reset_ex(model->u.content, &pos);
                            while (zend_hash_get_current_data_ex(model->u.content, (void**)&tmp, &pos) == SUCCESS) {
                                   (*tmp)->min_occurs = 0;
                                   (*tmp)->max_occurs = model->max_occurs;
                                   zend_hash_move_forward_ex(model->u.content, &pos);
                            }

                            model->kind = XSD_CONTENT_ALL;
                            model->min_occurs = 1;
                            model->max_occurs = 1;
                     }
              }
              case XSD_CONTENT_SEQUENCE:
              case XSD_CONTENT_ALL: {
                     sdlContentModelPtr *tmp;

                     zend_hash_internal_pointer_reset(model->u.content);
                     while (zend_hash_get_current_data(model->u.content, (void**)&tmp) == SUCCESS) {
                            schema_content_model_fixup(ctx, *tmp);
                            zend_hash_move_forward(model->u.content);
                     }
                     break;
              }
              default:
                     break;
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int schema_element ( sdlPtr  sdl,
xmlAttrPtr  tns,
xmlNodePtr  element,
sdlTypePtr  cur_type,
sdlContentModelPtr  model 
) [static]

Definition at line 1478 of file php_schema.c.

{
       xmlNodePtr trav;
       xmlAttrPtr attrs, attr, ns, name, type, ref = NULL;

       attrs = element->properties;
       ns = get_attribute(attrs, "targetNamespace");
       if (ns == NULL) {
              ns = tns;
       }

       name = get_attribute(attrs, "name");
       if (name == NULL) {
              name = ref = get_attribute(attrs, "ref");
       }

       if (name) {
              HashTable *addHash;
              sdlTypePtr newType;
              smart_str key = {0};

              newType = emalloc(sizeof(sdlType));
              memset(newType, 0, sizeof(sdlType));

              if (ref) {
                     smart_str nscat = {0};
                     char *type, *ns;
                     xmlNsPtr nsptr;

                     parse_namespace(ref->children->content, &type, &ns);
                     nsptr = xmlSearchNs(element->doc, element, BAD_CAST(ns));
                     if (nsptr != NULL) {
                            smart_str_appends(&nscat, (char*)nsptr->href);
                            newType->namens = estrdup((char*)nsptr->href);
                     } 
                     smart_str_appendc(&nscat, ':');
                     smart_str_appends(&nscat, type);
                     newType->name = estrdup(type);
                     smart_str_0(&nscat);
                     if (type) {efree(type);}
                     if (ns) {efree(ns);}
                     newType->ref = estrdup(nscat.c);
                     smart_str_free(&nscat);
              } else {
                     newType->name = estrdup((char*)name->children->content);
                     newType->namens = estrdup((char*)ns->children->content);
              }

              newType->nillable = FALSE;

              if (cur_type == NULL) {
                     if (sdl->elements == NULL) {
                            sdl->elements = emalloc(sizeof(HashTable));
                            zend_hash_init(sdl->elements, 0, NULL, delete_type, 0);
                     }
                     addHash = sdl->elements;
                     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 = emalloc(sizeof(HashTable));
                            zend_hash_init(cur_type->elements, 0, NULL, delete_type, 0);
                     }
                     addHash = cur_type->elements;
                     smart_str_appends(&key, newType->name);
              }

              smart_str_0(&key);
              if (zend_hash_add(addHash, key.c, key.len + 1, &newType, sizeof(sdlTypePtr), NULL) != SUCCESS) {
                     if (cur_type == NULL) {
                            soap_error1(E_ERROR, "Parsing Schema: element '%s' already defined", key.c);
                     } else {
                            zend_hash_next_index_insert(addHash, &newType, sizeof(sdlTypePtr), NULL);
                     }
              }
              smart_str_free(&key);

              if (model != NULL) {
                     sdlContentModelPtr newModel = emalloc(sizeof(sdlContentModel));

                     newModel->kind = XSD_CONTENT_ELEMENT;
                     newModel->u.element = newType;

                     schema_min_max(element, newModel);


                     zend_hash_next_index_insert(model->u.content, &newModel, sizeof(sdlContentModelPtr), NULL);
              }
              cur_type = newType;
       } else {
              soap_error0(E_ERROR, "Parsing Schema: element has no 'name' nor 'ref' attributes");
       }

       /* nillable = boolean : false */
       attrs = element->properties;
       attr = get_attribute(attrs, "nillable");
       if (attr) {
              if (ref != NULL) {
                     soap_error0(E_ERROR, "Parsing Schema: element has both 'ref' and 'nillable' attributes");
              }
              if (!stricmp((char*)attr->children->content, "true") ||
                     !stricmp((char*)attr->children->content, "1")) {
                     cur_type->nillable = TRUE;
              } else {
                     cur_type->nillable = FALSE;
              }
       } else {
              cur_type->nillable = FALSE;
       }

       attr = get_attribute(attrs, "fixed");
       if (attr) {
              if (ref != NULL) {
                     soap_error0(E_ERROR, "Parsing Schema: element has both 'ref' and 'fixed' attributes");
              }
              cur_type->fixed = estrdup((char*)attr->children->content);
       }

       attr = get_attribute(attrs, "default");
       if (attr) {
              if (ref != NULL) {
                     soap_error0(E_ERROR, "Parsing Schema: element has both 'ref' and 'fixed' attributes");
              } else if (ref != NULL) {
                     soap_error0(E_ERROR, "Parsing Schema: element has both 'default' and 'fixed' attributes");
              }
              cur_type->def = estrdup((char*)attr->children->content);
       }

       /* form */
       attr = get_attribute(attrs, "form");
       if (attr) {
              if (strncmp((char*)attr->children->content, "qualified", sizeof("qualified")) == 0) {
                cur_type->form = XSD_FORM_QUALIFIED;
              } else if (strncmp((char*)attr->children->content, "unqualified", sizeof("unqualified")) == 0) {
                cur_type->form = XSD_FORM_UNQUALIFIED;
              } else {
                cur_type->form = XSD_FORM_DEFAULT;
              }
       } else {
         cur_type->form = XSD_FORM_DEFAULT;
       }
       if (cur_type->form == XSD_FORM_DEFAULT) {
              xmlNodePtr parent = element->parent;
              while (parent) {
                     if (node_is_equal_ex(parent, "schema", SCHEMA_NAMESPACE)) {
                            xmlAttrPtr def;
                            def = get_attribute(parent->properties, "elementFormDefault");
                            if(def == NULL || strncmp((char*)def->children->content, "qualified", sizeof("qualified"))) {
                                   cur_type->form = XSD_FORM_UNQUALIFIED;
                            } else {
                                   cur_type->form = XSD_FORM_QUALIFIED;
                            }
                            break;
                     }
                     parent = parent->parent;
       }
              if (parent == NULL) {
                     cur_type->form = XSD_FORM_UNQUALIFIED;
              }      
       }

       /* type = QName */
       type = get_attribute(attrs, "type");
       if (type) {
              char *cptype, *str_ns;
              xmlNsPtr nsptr;

              if (ref != NULL) {
                     soap_error0(E_ERROR, "Parsing Schema: element has both 'ref' and 'type' attributes");
              }
              parse_namespace(type->children->content, &cptype, &str_ns);
              nsptr = xmlSearchNs(element->doc, element, BAD_CAST(str_ns));
              if (nsptr != NULL) {
                     cur_type->encode = get_create_encoder(sdl, cur_type, nsptr->href, BAD_CAST(cptype));
              }
              if (str_ns) {efree(str_ns);}
              if (cptype) {efree(cptype);}
       }

       trav = element->children;
       if (trav != NULL && node_is_equal(trav, "annotation")) {
              /* TODO: <annotation> support */
              trav = trav->next;
       }
       if (trav != NULL) {
              if (node_is_equal(trav,"simpleType")) {
                     if (ref != NULL) {
                            soap_error0(E_ERROR, "Parsing Schema: element has both 'ref' attribute and subtype");
                     } else if (type != NULL) {
                            soap_error0(E_ERROR, "Parsing Schema: element has both 'type' attribute and subtype");
                     }
                     schema_simpleType(sdl, tns, trav, cur_type);
                     trav = trav->next;
              } else if (node_is_equal(trav,"complexType")) {
                     if (ref != NULL) {
                            soap_error0(E_ERROR, "Parsing Schema: element has both 'ref' attribute and subtype");
                     } else if (type != NULL) {
                            soap_error0(E_ERROR, "Parsing Schema: element has both 'type' attribute and subtype");
                     }
                     schema_complexType(sdl, tns, trav, cur_type);
                     trav = trav->next;
              }
       }
       while (trav != NULL) {
              if (node_is_equal(trav,"unique")) {
                     /* TODO: <unique> support */
              } else if (node_is_equal(trav,"key")) {
                     /* TODO: <key> support */
              } else if (node_is_equal(trav,"keyref")) {
                     /* TODO: <keyref> support */
              } else {
                     soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in element", trav->name);
              }
              trav = trav->next;
       }

       return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int schema_extension_complexContent ( sdlPtr  sdl,
xmlAttrPtr  tns,
xmlNodePtr  extType,
sdlTypePtr  cur_type 
) [static]

Definition at line 921 of file php_schema.c.

{
       xmlNodePtr trav;
       xmlAttrPtr base;

       base = get_attribute(extType->properties, "base");
       if (base != NULL) {
              char *type, *ns;
              xmlNsPtr nsptr;

              parse_namespace(base->children->content, &type, &ns);
              nsptr = xmlSearchNs(extType->doc, extType, BAD_CAST(ns));
              if (nsptr != NULL) {
                     cur_type->encode = get_create_encoder(sdl, cur_type, nsptr->href, BAD_CAST(type));
              }
              if (type) {efree(type);}
              if (ns) {efree(ns);}
       } else {
              soap_error0(E_ERROR, "Parsing Schema: extension has no 'base' attribute");
       }

       trav = extType->children;
       if (trav != NULL && node_is_equal(trav,"annotation")) {
              /* TODO: <annotation> support */
              trav = trav->next;
       }
       if (trav != NULL) {
              if (node_is_equal(trav,"group")) {
                     schema_group(sdl, tns, trav, cur_type, NULL);
                     trav = trav->next;
              } else if (node_is_equal(trav,"all")) {
                     schema_all(sdl, tns, trav, cur_type, NULL);
                     trav = trav->next;
              } else if (node_is_equal(trav,"choice")) {
                     schema_choice(sdl, tns, trav, cur_type, NULL);
                     trav = trav->next;
              } else if (node_is_equal(trav,"sequence")) {
                     schema_sequence(sdl, tns, trav, cur_type, NULL);
                     trav = trav->next;
              }
       }
       while (trav != NULL) {
              if (node_is_equal(trav,"attribute")) {
                     schema_attribute(sdl, tns, trav, cur_type, NULL);
              } else if (node_is_equal(trav,"attributeGroup")) {
                     schema_attributeGroup(sdl, tns, trav, cur_type, NULL);
              } else if (node_is_equal(trav,"anyAttribute")) {
                     /* TODO: <anyAttribute> support */
                     trav = trav->next;
                     break;
              } else {
                     soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in extension", trav->name);
              }
              trav = trav->next;
       }
       if (trav != NULL) {
              soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in extension", trav->name);
       }
       return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int schema_extension_simpleContent ( sdlPtr  sdl,
xmlAttrPtr  tns,
xmlNodePtr  extType,
sdlTypePtr  cur_type 
) [static]

Definition at line 866 of file php_schema.c.

{
       xmlNodePtr trav;
       xmlAttrPtr base;

       base = get_attribute(extType->properties, "base");
       if (base != NULL) {
              char *type, *ns;
              xmlNsPtr nsptr;

              parse_namespace(base->children->content, &type, &ns);
              nsptr = xmlSearchNs(extType->doc, extType, BAD_CAST(ns));
              if (nsptr != NULL) {
                     cur_type->encode = get_create_encoder(sdl, cur_type, nsptr->href, BAD_CAST(type));
              }
              if (type) {efree(type);}
              if (ns) {efree(ns);}
       } else {
              soap_error0(E_ERROR, "Parsing Schema: extension has no 'base' attribute");
       }

       trav = extType->children;
       if (trav != NULL && node_is_equal(trav,"annotation")) {
              /* TODO: <annotation> support */
              trav = trav->next;
       }
       while (trav != NULL) {
              if (node_is_equal(trav,"attribute")) {
                     schema_attribute(sdl, tns, trav, cur_type, NULL);
              } else if (node_is_equal(trav,"attributeGroup")) {
                     schema_attributeGroup(sdl, tns, trav, cur_type, NULL);
              } else if (node_is_equal(trav,"anyAttribute")) {
                     /* TODO: <anyAttribute> support */
                     trav = trav->next;
                     break;
              } else {
                     soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in extension", trav->name);
              }
              trav = trav->next;
       }
       if (trav != NULL) {
              soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in extension", trav->name);
       }
       return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int schema_group ( sdlPtr  sdl,
xmlAttrPtr  tns,
xmlNodePtr  groupType,
sdlTypePtr  cur_type,
sdlContentModelPtr  model 
) [static]

Definition at line 1057 of file php_schema.c.

{
       xmlNodePtr trav;
       xmlAttrPtr ns, name, ref = NULL;
       sdlContentModelPtr newModel;

       ns = get_attribute(groupType->properties, "targetNamespace");
       if (ns == NULL) {
              ns = tns;
       }

       name = get_attribute(groupType->properties, "name");
       if (name == NULL) {
              name = ref = get_attribute(groupType->properties, "ref");
       }

       if (name) {
              smart_str key = {0};

              if (ref) {
                     char *type, *ns;
                     xmlNsPtr nsptr;

                     parse_namespace(ref->children->content, &type, &ns);
                     nsptr = xmlSearchNs(groupType->doc, groupType, BAD_CAST(ns));
                     if (nsptr != NULL) {
                            smart_str_appends(&key, (char*)nsptr->href);
                     }
                     smart_str_appendc(&key, ':');
                     smart_str_appends(&key, type);
                     smart_str_0(&key);

                     newModel = emalloc(sizeof(sdlContentModel));
                     newModel->kind = XSD_CONTENT_GROUP_REF;
                     newModel->u.group_ref = estrdup(key.c);

                     if (type) {efree(type);}
                     if (ns) {efree(ns);}
              } else {
                     newModel = emalloc(sizeof(sdlContentModel));
                     newModel->kind = XSD_CONTENT_SEQUENCE; /* will be redefined */
                     newModel->u.content = emalloc(sizeof(HashTable));
                     zend_hash_init(newModel->u.content, 0, NULL, delete_model, 0);

                     smart_str_appends(&key, (char*)ns->children->content);
                     smart_str_appendc(&key, ':');
                     smart_str_appends(&key, (char*)name->children->content);
                     smart_str_0(&key);
              }

              if (cur_type == NULL) {
                     sdlTypePtr newType;

                     newType = emalloc(sizeof(sdlType));
                     memset(newType, 0, sizeof(sdlType));

                     if (sdl->groups == NULL) {
                            sdl->groups = emalloc(sizeof(HashTable));
                            zend_hash_init(sdl->groups, 0, NULL, delete_type, 0);
                     }
                     if (zend_hash_add(sdl->groups, key.c, key.len+1, (void**)&newType, sizeof(sdlTypePtr), NULL) != SUCCESS) {
                            soap_error1(E_ERROR, "Parsing Schema: group '%s' already defined", key.c);
                     }

                     cur_type = newType;
              }
              smart_str_free(&key);

              if (model == NULL) {
                     cur_type->model = newModel;
              } else {
                     zend_hash_next_index_insert(model->u.content, &newModel, sizeof(sdlContentModelPtr), NULL);
              }
       } else {
              soap_error0(E_ERROR, "Parsing Schema: group has no 'name' nor 'ref' attributes");
       }

       schema_min_max(groupType, newModel);

       trav = groupType->children;
       if (trav != NULL && node_is_equal(trav,"annotation")) {
              /* TODO: <annotation> support */
              trav = trav->next;
       }
       if (trav != NULL) {
              if (node_is_equal(trav,"choice")) {
                     if (ref != NULL) {
                            soap_error0(E_ERROR, "Parsing Schema: group has both 'ref' attribute and subcontent");
                     }
                     newModel->kind = XSD_CONTENT_CHOICE;
                     schema_choice(sdl, tns, trav, cur_type, newModel);
                     trav = trav->next;
              } else if (node_is_equal(trav,"sequence")) {
                     if (ref != NULL) {
                            soap_error0(E_ERROR, "Parsing Schema: group has both 'ref' attribute and subcontent");
                     }
                     newModel->kind = XSD_CONTENT_SEQUENCE;
                     schema_sequence(sdl, tns, trav, cur_type, newModel);
                     trav = trav->next;
              } else if (node_is_equal(trav,"all")) {
                     if (ref != NULL) {
                            soap_error0(E_ERROR, "Parsing Schema: group has both 'ref' attribute and subcontent");
                     }
                     newModel->kind = XSD_CONTENT_ALL;
                     schema_all(sdl, tns, trav, cur_type, newModel);
                     trav = trav->next;
              } else {
                     soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in group", trav->name);
              }
       }
       if (trav != NULL) {
              soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in group", trav->name);
       }
       return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int schema_list ( sdlPtr  sdl,
xmlAttrPtr  tns,
xmlNodePtr  listType,
sdlTypePtr  cur_type 
) [static]

Definition at line 411 of file php_schema.c.

{
       xmlNodePtr trav;
       xmlAttrPtr itemType;

       itemType = get_attribute(listType->properties, "itemType");
       if (itemType != NULL) {
              char *type, *ns;
              xmlNsPtr nsptr;

              parse_namespace(itemType->children->content, &type, &ns);
              nsptr = xmlSearchNs(listType->doc, listType, BAD_CAST(ns));
              if (nsptr != NULL) {
                     sdlTypePtr newType, *tmp;

                     newType = emalloc(sizeof(sdlType));
                     memset(newType, 0, sizeof(sdlType));

                     newType->name = estrdup(type);
                     newType->namens = estrdup((char*)nsptr->href);

                     newType->encode = get_create_encoder(sdl, newType, nsptr->href, BAD_CAST(type));

                     if (cur_type->elements == NULL) {
                            cur_type->elements = emalloc(sizeof(HashTable));
                            zend_hash_init(cur_type->elements, 0, NULL, delete_type, 0);
                     }
                     zend_hash_next_index_insert(cur_type->elements, &newType, sizeof(sdlTypePtr), (void **)&tmp);
              }
              if (type) {efree(type);}
              if (ns) {efree(ns);}
       }

       trav = listType->children;
       if (trav != NULL && node_is_equal(trav,"annotation")) {
              /* TODO: <annotation> support */
              trav = trav->next;
       }
       if (trav != NULL && node_is_equal(trav,"simpleType")) {
              sdlTypePtr newType, *tmp;

              if (itemType != NULL) {
                     soap_error0(E_ERROR, "Parsing Schema: element has both 'itemType' attribute and subtype");
              }

              newType = emalloc(sizeof(sdlType));
              memset(newType, 0, sizeof(sdlType));

              {
                     smart_str anonymous = {0};
                     
                     smart_str_appendl(&anonymous, "anonymous", sizeof("anonymous")-1);
                     smart_str_append_long(&anonymous, zend_hash_num_elements(sdl->types));
                     smart_str_0(&anonymous);
                     newType->name = anonymous.c;
              }
              newType->namens = estrdup((char*)tns->children->content);

              if (cur_type->elements == NULL) {
                     cur_type->elements = emalloc(sizeof(HashTable));
                     zend_hash_init(cur_type->elements, 0, NULL, delete_type, 0);
              }
              zend_hash_next_index_insert(cur_type->elements, &newType, sizeof(sdlTypePtr), (void **)&tmp);

              schema_simpleType(sdl, tns, trav, newType);

              trav = trav->next;
       }
       if (trav != NULL) {
              soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in list", trav->name);
       }
       return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void schema_load_file ( sdlCtx ctx,
xmlAttrPtr  ns,
xmlChar *  location,
xmlAttrPtr  tns,
int import  TSRMLS_DC 
) [static]

Definition at line 98 of file php_schema.c.

                                                                                                                  {
       if (location != NULL &&
           !zend_hash_exists(&ctx->docs, (char*)location, xmlStrlen(location)+1)) {
              xmlDocPtr doc;
              xmlNodePtr schema;
              xmlAttrPtr new_tns;

              sdl_set_uri_credentials(ctx, (char*)location TSRMLS_CC);
              doc = soap_xmlParseFile((char*)location TSRMLS_CC);
              sdl_restore_uri_credentials(ctx TSRMLS_CC);

              if (doc == NULL) {
                     soap_error1(E_ERROR, "Parsing Schema: can't import schema from '%s'", location);
              }
              schema = get_node(doc->children, "schema");
              if (schema == NULL) {
                     xmlFreeDoc(doc);
                     soap_error1(E_ERROR, "Parsing Schema: can't import schema from '%s'", location);
              }
              new_tns = get_attribute(schema->properties, "targetNamespace");
              if (import) {
                     if (ns != NULL && (new_tns == NULL || xmlStrcmp(ns->children->content, new_tns->children->content) != 0)) {
                            xmlFreeDoc(doc);
                            soap_error2(E_ERROR, "Parsing Schema: can't import schema from '%s', unexpected 'targetNamespace'='%s'", location, ns->children->content);
                     }
                     if (ns == NULL && new_tns != NULL) {
                            xmlFreeDoc(doc);
                            soap_error2(E_ERROR, "Parsing Schema: can't import schema from '%s', unexpected 'targetNamespace'='%s'", location, new_tns->children->content);
                     }
              } else {
                     new_tns = get_attribute(schema->properties, "targetNamespace");
                     if (new_tns == NULL) {
                            if (tns != NULL) {
                                   xmlSetProp(schema, BAD_CAST("targetNamespace"), tns->children->content);
                            }
                     } else if (tns != NULL && xmlStrcmp(tns->children->content, new_tns->children->content) != 0) {
                            xmlFreeDoc(doc);
                            soap_error1(E_ERROR, "Parsing Schema: can't include schema from '%s', different 'targetNamespace'", location);
                     }
              }
              zend_hash_add(&ctx->docs, (char*)location, xmlStrlen(location)+1, (void**)&doc, sizeof(xmlDocPtr), NULL);
              load_schema(ctx, schema TSRMLS_CC);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void schema_min_max ( xmlNodePtr  node,
sdlContentModelPtr  model 
)

Definition at line 982 of file php_schema.c.

{
       xmlAttrPtr attr = get_attribute(node->properties, "minOccurs");

       if (attr) {
              model->min_occurs = atoi((char*)attr->children->content);
       } else {
              model->min_occurs = 1;
       }

       attr = get_attribute(node->properties, "maxOccurs");
       if (attr) {
              if (!strncmp((char*)attr->children->content, "unbounded", sizeof("unbounded"))) {
                     model->max_occurs = -1;
              } else {
                     model->max_occurs = atoi((char*)attr->children->content);
              }
       } else {
              model->max_occurs = 1;
       }
}

Here is the caller graph for this function:

void schema_pass2 ( sdlCtx ctx)

Definition at line 2245 of file php_schema.c.

{
       sdlPtr sdl = ctx->sdl;
       sdlAttributePtr *attr;
       sdlTypePtr *type;

       if (ctx->attributes) {
              zend_hash_internal_pointer_reset(ctx->attributes);
              while (zend_hash_get_current_data(ctx->attributes,(void**)&attr) == SUCCESS) {
                     schema_attribute_fixup(ctx,*attr);
                     zend_hash_move_forward(ctx->attributes);
              }
       }
       if (ctx->attributeGroups) {
              zend_hash_internal_pointer_reset(ctx->attributeGroups);
              while (zend_hash_get_current_data(ctx->attributeGroups,(void**)&type) == SUCCESS) {
                     schema_type_fixup(ctx,*type);
                     zend_hash_move_forward(ctx->attributeGroups);
              }
       }
       if (sdl->elements) {
              zend_hash_internal_pointer_reset(sdl->elements);
              while (zend_hash_get_current_data(sdl->elements,(void**)&type) == SUCCESS) {
                     schema_type_fixup(ctx,*type);
                     zend_hash_move_forward(sdl->elements);
              }
       }
       if (sdl->groups) {
              zend_hash_internal_pointer_reset(sdl->groups);
              while (zend_hash_get_current_data(sdl->groups,(void**)&type) == SUCCESS) {
                     schema_type_fixup(ctx,*type);
                     zend_hash_move_forward(sdl->groups);
              }
       }
       if (sdl->types) {
              zend_hash_internal_pointer_reset(sdl->types);
              while (zend_hash_get_current_data(sdl->types,(void**)&type) == SUCCESS) {
                     schema_type_fixup(ctx,*type);
                     zend_hash_move_forward(sdl->types);
              }
       }
       if (ctx->attributes) {
              zend_hash_destroy(ctx->attributes);
              efree(ctx->attributes);
       }
       if (ctx->attributeGroups) {
              zend_hash_destroy(ctx->attributeGroups);
              efree(ctx->attributeGroups);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int schema_restriction_complexContent ( sdlPtr  sdl,
xmlAttrPtr  tns,
xmlNodePtr  restType,
sdlTypePtr  cur_type 
) [static]

Definition at line 741 of file php_schema.c.

{
       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, BAD_CAST(ns));
              if (nsptr != NULL) {
                     cur_type->encode = get_create_encoder(sdl, cur_type, nsptr->href, BAD_CAST(type));
              }
              if (type) {efree(type);}
              if (ns) {efree(ns);}
       } else {
              soap_error0(E_ERROR, "Parsing Schema: restriction has no 'base' attribute");
       }

       trav = restType->children;
       if (trav != NULL && node_is_equal(trav,"annotation")) {
              /* TODO: <annotation> support */
              trav = trav->next;
       }
       if (trav != NULL) {
              if (node_is_equal(trav,"group")) {
                     schema_group(sdl, tns, trav, cur_type, NULL);
                     trav = trav->next;
              } else if (node_is_equal(trav,"all")) {
                     schema_all(sdl, tns, trav, cur_type, NULL);
                     trav = trav->next;
              } else if (node_is_equal(trav,"choice")) {
                     schema_choice(sdl, tns, trav, cur_type, NULL);
                     trav = trav->next;
              } else if (node_is_equal(trav,"sequence")) {
                     schema_sequence(sdl, tns, trav, cur_type, NULL);
                     trav = trav->next;
              }
       }
       while (trav != NULL) {
              if (node_is_equal(trav,"attribute")) {
                     schema_attribute(sdl, tns, trav, cur_type, NULL);
              } else if (node_is_equal(trav,"attributeGroup")) {
                     schema_attributeGroup(sdl, tns, trav, cur_type, NULL);
              } else if (node_is_equal(trav,"anyAttribute")) {
                     /* TODO: <anyAttribute> support */
                     trav = trav->next;
                     break;
              } else {
                     soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in restriction", trav->name);
              }
              trav = trav->next;
       }
       if (trav != NULL) {
              soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in restriction", trav->name);
       }

       return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int schema_restriction_simpleContent ( sdlPtr  sdl,
xmlAttrPtr  tns,
xmlNodePtr  restType,
sdlTypePtr  cur_type,
int  simpleType 
) [static]

Definition at line 636 of file php_schema.c.

{
       xmlNodePtr trav;
       xmlAttrPtr base;

       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, BAD_CAST(ns));
              if (nsptr != NULL) {
                     cur_type->encode = get_create_encoder(sdl, cur_type, nsptr->href, BAD_CAST(type));
              }
              if (type) {efree(type);}
              if (ns) {efree(ns);}
       } else if (!simpleType) {
              soap_error0(E_ERROR, "Parsing Schema: restriction has no 'base' attribute");
       }

       if (cur_type->restrictions == NULL) {
              cur_type->restrictions = emalloc(sizeof(sdlRestrictions));
              memset(cur_type->restrictions, 0, sizeof(sdlRestrictions));
       }

       trav = restType->children;
       if (trav != NULL && node_is_equal(trav, "annotation")) {
              /* TODO: <annotation> support */
              trav = trav->next;
       }
       if (trav != NULL && node_is_equal(trav, "simpleType")) {
              schema_simpleType(sdl, tns, trav, cur_type);
              trav = trav->next;
       }
       while (trav != NULL) {
              if (node_is_equal(trav, "minExclusive")) {
                     schema_restriction_var_int(trav, &cur_type->restrictions->minExclusive);
              } else if (node_is_equal(trav, "minInclusive")) {
                     schema_restriction_var_int(trav, &cur_type->restrictions->minInclusive);
              } else if (node_is_equal(trav, "maxExclusive")) {
                     schema_restriction_var_int(trav, &cur_type->restrictions->maxExclusive);
              } else if (node_is_equal(trav, "maxInclusive")) {
                     schema_restriction_var_int(trav, &cur_type->restrictions->maxInclusive);
              } else if (node_is_equal(trav, "totalDigits")) {
                     schema_restriction_var_int(trav, &cur_type->restrictions->totalDigits);
              } else if (node_is_equal(trav, "fractionDigits")) {
                     schema_restriction_var_int(trav, &cur_type->restrictions->fractionDigits);
              } else if (node_is_equal(trav, "length")) {
                     schema_restriction_var_int(trav, &cur_type->restrictions->length);
              } else if (node_is_equal(trav, "minLength")) {
                     schema_restriction_var_int(trav, &cur_type->restrictions->minLength);
              } else if (node_is_equal(trav, "maxLength")) {
                     schema_restriction_var_int(trav, &cur_type->restrictions->maxLength);
              } else if (node_is_equal(trav, "whiteSpace")) {
                     schema_restriction_var_char(trav, &cur_type->restrictions->whiteSpace);
              } else if (node_is_equal(trav, "pattern")) {
                     schema_restriction_var_char(trav, &cur_type->restrictions->pattern);
              } else if (node_is_equal(trav, "enumeration")) {
                     sdlRestrictionCharPtr enumval = NULL;

                     schema_restriction_var_char(trav, &enumval);
                     if (cur_type->restrictions->enumeration == NULL) {
                            cur_type->restrictions->enumeration = emalloc(sizeof(HashTable));
                            zend_hash_init(cur_type->restrictions->enumeration, 0, NULL, delete_restriction_var_char, 0);
                     }
                     if (zend_hash_add(cur_type->restrictions->enumeration, enumval->value, strlen(enumval->value)+1, &enumval, sizeof(sdlRestrictionCharPtr), NULL) == FAILURE) {
                            delete_restriction_var_char(&enumval);
                     }
              } else {
                     break;
              }
              trav = trav->next;
       }
       if (!simpleType) {
              while (trav != NULL) {
                     if (node_is_equal(trav,"attribute")) {
                            schema_attribute(sdl, tns, trav, cur_type, NULL);
                     } else if (node_is_equal(trav,"attributeGroup")) {
                            schema_attributeGroup(sdl, tns, trav, cur_type, NULL);
                     } else if (node_is_equal(trav,"anyAttribute")) {
                            /* TODO: <anyAttribute> support */
                            trav = trav->next;
                            break;
                     } else {
                            soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in restriction", trav->name);
                     }
                     trav = trav->next;
              }
       }
       if (trav != NULL) {
              soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in restriction", trav->name);
       }

       return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int schema_restriction_var_char ( xmlNodePtr  val,
sdlRestrictionCharPtr valptr 
) [static]

Definition at line 830 of file php_schema.c.

{
       xmlAttrPtr fixed, value;

       if ((*valptr) == NULL) {
              (*valptr) = emalloc(sizeof(sdlRestrictionChar));
       }
       memset((*valptr), 0, sizeof(sdlRestrictionChar));

       fixed = get_attribute(val->properties, "fixed");
       (*valptr)->fixed = FALSE;
       if (fixed != NULL) {
              if (!strncmp((char*)fixed->children->content, "true", sizeof("true")) ||
                  !strncmp((char*)fixed->children->content, "1", sizeof("1"))) {
                     (*valptr)->fixed = TRUE;
              }
       }

       value = get_attribute(val->properties, "value");
       if (value == NULL) {
              soap_error0(E_ERROR, "Parsing Schema: missing restriction value");
       }

       (*valptr)->value = estrdup((char*)value->children->content);
       return TRUE;
}

Here is the caller graph for this function:

static int schema_restriction_var_int ( xmlNodePtr  val,
sdlRestrictionIntPtr valptr 
) [static]

Definition at line 803 of file php_schema.c.

{
       xmlAttrPtr fixed, value;

       if ((*valptr) == NULL) {
              (*valptr) = emalloc(sizeof(sdlRestrictionInt));
       }
       memset((*valptr), 0, sizeof(sdlRestrictionInt));

       fixed = get_attribute(val->properties, "fixed");
       (*valptr)->fixed = FALSE;
       if (fixed != NULL) {
              if (!strncmp((char*)fixed->children->content, "true", sizeof("true")) ||
                     !strncmp((char*)fixed->children->content, "1", sizeof("1")))
                     (*valptr)->fixed = TRUE;
       }

       value = get_attribute(val->properties, "value");
       if (value == NULL) {
              soap_error0(E_ERROR, "Parsing Schema: missing restriction value");
       }

       (*valptr)->value = atoi((char*)value->children->content);

       return TRUE;
}

Here is the caller graph for this function:

static int schema_sequence ( sdlPtr  sdl,
xmlAttrPtr  tns,
xmlNodePtr  seqType,
sdlTypePtr  cur_type,
sdlContentModelPtr  model 
) [static]

Definition at line 1231 of file php_schema.c.

{
       xmlNodePtr trav;
       sdlContentModelPtr newModel;

       newModel = emalloc(sizeof(sdlContentModel));
       newModel->kind = XSD_CONTENT_SEQUENCE;
       newModel->u.content = emalloc(sizeof(HashTable));
       zend_hash_init(newModel->u.content, 0, NULL, delete_model, 0);
       if (model == NULL) {
              cur_type->model = newModel;
       } else {
              zend_hash_next_index_insert(model->u.content,&newModel,sizeof(sdlContentModelPtr), NULL);
       }

       schema_min_max(seqType, newModel);

       trav = seqType->children;
       if (trav != NULL && node_is_equal(trav,"annotation")) {
              /* TODO: <annotation> support */
              trav = trav->next;
       }
       while (trav != NULL) {
              if (node_is_equal(trav,"element")) {
                     schema_element(sdl, tns, trav, cur_type, newModel);
              } else if (node_is_equal(trav,"group")) {
                     schema_group(sdl, tns, trav, cur_type, newModel);
              } else if (node_is_equal(trav,"choice")) {
                     schema_choice(sdl, tns, trav, cur_type, newModel);
              } else if (node_is_equal(trav,"sequence")) {
                     schema_sequence(sdl, tns, trav, cur_type, newModel);
              } else if (node_is_equal(trav,"any")) {
                     schema_any(sdl, tns, trav, cur_type, newModel);
              } else {
                     soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in sequence", trav->name);
              }
              trav = trav->next;
       }
       return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int schema_simpleContent ( sdlPtr  sdl,
xmlAttrPtr  tns,
xmlNodePtr  simpCompType,
sdlTypePtr  cur_type 
) [static]

Definition at line 591 of file php_schema.c.

{
       xmlNodePtr trav;

       trav = simpCompType->children;
       if (trav != NULL && node_is_equal(trav,"annotation")) {
              /* TODO: <annotation> support */
              trav = trav->next;
       }
       if (trav != NULL) {
              if (node_is_equal(trav, "restriction")) {
                     cur_type->kind = XSD_TYPEKIND_RESTRICTION;
                     schema_restriction_simpleContent(sdl, tns, trav, cur_type, 0);
                     trav = trav->next;
              } else if (node_is_equal(trav, "extension")) {
                     cur_type->kind = XSD_TYPEKIND_EXTENSION;
                     schema_extension_simpleContent(sdl, tns, trav, cur_type);
                     trav = trav->next;
              } else {
                     soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in simpleContent", trav->name);
              }
       } else {
              soap_error0(E_ERROR, "Parsing Schema: expected <restriction> or <extension> in simpleContent");
       }
       if (trav != NULL) {
              soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in simpleContent", trav->name);
       }

       return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int schema_simpleType ( sdlPtr  sdl,
xmlAttrPtr  tns,
xmlNodePtr  simpleType,
sdlTypePtr  cur_type 
) [static]

Definition at line 305 of file php_schema.c.

{
       xmlNodePtr trav;
       xmlAttrPtr name, ns;

       ns = get_attribute(simpleType->properties, "targetNamespace");
       if (ns == NULL) {
              ns = tns;
       }

       name = get_attribute(simpleType->properties, "name");
       if (cur_type != NULL) {
              /* Anonymous type inside <element> or <restriction> */
              sdlTypePtr newType, *ptr;

              newType = emalloc(sizeof(sdlType));
              memset(newType, 0, sizeof(sdlType));
              newType->kind = XSD_TYPEKIND_SIMPLE;
              if (name != NULL) {
                     newType->name = estrdup((char*)name->children->content);
                     newType->namens = estrdup((char*)ns->children->content);
              } else {
                     newType->name = estrdup(cur_type->name);
                     newType->namens = estrdup(cur_type->namens);
              }

              zend_hash_next_index_insert(sdl->types,  &newType, sizeof(sdlTypePtr), (void **)&ptr);

              if (sdl->encoders == NULL) {
                     sdl->encoders = emalloc(sizeof(HashTable));
                     zend_hash_init(sdl->encoders, 0, NULL, delete_encoder, 0);
              }
              cur_type->encode = emalloc(sizeof(encode));
              memset(cur_type->encode, 0, sizeof(encode));
              cur_type->encode->details.ns = estrdup(newType->namens);
              cur_type->encode->details.type_str = estrdup(newType->name);
              cur_type->encode->details.sdl_type = *ptr;
              cur_type->encode->to_xml = sdl_guess_convert_xml;
              cur_type->encode->to_zval = sdl_guess_convert_zval;
              zend_hash_next_index_insert(sdl->encoders,  &cur_type->encode, sizeof(encodePtr), NULL);

              cur_type =*ptr;

       } else if (name != NULL) {
              sdlTypePtr newType, *ptr;

              newType = emalloc(sizeof(sdlType));
              memset(newType, 0, sizeof(sdlType));
              newType->kind = XSD_TYPEKIND_SIMPLE;
              newType->name = estrdup((char*)name->children->content);
              newType->namens = estrdup((char*)ns->children->content);

              if (cur_type == NULL) {
                     zend_hash_next_index_insert(sdl->types,  &newType, sizeof(sdlTypePtr), (void **)&ptr);
              } else {
                     if (cur_type->elements == NULL) {
                            cur_type->elements = emalloc(sizeof(HashTable));
                            zend_hash_init(cur_type->elements, 0, NULL, delete_type, 0);
                     }
                     zend_hash_update(cur_type->elements, newType->name, strlen(newType->name)+1, &newType, sizeof(sdlTypePtr), (void **)&ptr);
              }
              cur_type = (*ptr);

              create_encoder(sdl, cur_type, ns->children->content, name->children->content);
       } else {
              soap_error0(E_ERROR, "Parsing Schema: simpleType has no 'name' attribute");
       }

       trav = simpleType->children;
       if (trav != NULL && node_is_equal(trav,"annotation")) {
              /* TODO: <annotation> support */
              trav = trav->next;
       }
       if (trav != NULL) {
              if (node_is_equal(trav,"restriction")) {
                     schema_restriction_simpleContent(sdl, tns, trav, cur_type, 1);
                     trav = trav->next;
              } else if (node_is_equal(trav,"list")) {
                     cur_type->kind = XSD_TYPEKIND_LIST;
                     schema_list(sdl, tns, trav, cur_type);
                     trav = trav->next;
              } else if (node_is_equal(trav,"union")) {
                     cur_type->kind = XSD_TYPEKIND_UNION;
                     schema_union(sdl, tns, trav, cur_type);
                     trav = trav->next;
              } else {
                     soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in simpleType", trav->name);
              }
       } else {
              soap_error0(E_ERROR, "Parsing Schema: expected <restriction>, <list> or <union> in simpleType");
       }
       if (trav != NULL) {
              soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in simpleType", trav->name);
       }

       return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void schema_type_fixup ( sdlCtx ctx,
sdlTypePtr  type 
) [static]

Definition at line 2189 of file php_schema.c.

{
       sdlTypePtr *tmp;
       sdlAttributePtr *attr;

       if (type->ref != NULL) {
              if (ctx->sdl->elements != NULL) {
                     if (zend_hash_find(ctx->sdl->elements, type->ref, strlen(type->ref)+1, (void**)&tmp) == SUCCESS) {
                            type->kind = (*tmp)->kind;
                            type->encode = (*tmp)->encode;
                            if ((*tmp)->nillable) {
                              type->nillable = 1;
                            }
                            if ((*tmp)->fixed) {
                              type->fixed = estrdup((*tmp)->fixed);
                            }
                            if ((*tmp)->def) {
                              type->def = estrdup((*tmp)->def);
                            }
                            type->form = (*tmp)->form;
                     } else if (strcmp(type->ref, SCHEMA_NAMESPACE ":schema") == 0) {
                            type->encode = get_conversion(XSD_ANYXML);
                     } else {
                            soap_error0(E_ERROR, "Parsing Schema: unresolved element 'ref' attribute");
                     }
              }
              efree(type->ref);
              type->ref = NULL;
       }
       if (type->elements) {
              zend_hash_internal_pointer_reset(type->elements);
              while (zend_hash_get_current_data(type->elements,(void**)&tmp) == SUCCESS) {
                     schema_type_fixup(ctx,*tmp);
                     zend_hash_move_forward(type->elements);
              }
       }
       if (type->model) {
              schema_content_model_fixup(ctx, type->model);
       }
       if (type->attributes) {
              zend_hash_internal_pointer_reset(type->attributes);
              while (zend_hash_get_current_data(type->attributes,(void**)&attr) == SUCCESS) {
                     if (zend_hash_get_current_key_type(type->attributes) == HASH_KEY_IS_STRING) {
                            schema_attribute_fixup(ctx,*attr);
                            zend_hash_move_forward(type->attributes);
                     } else {
                            ulong index;

                            schema_attributegroup_fixup(ctx,*attr,type->attributes);
                            zend_hash_get_current_key(type->attributes, NULL, &index, 0);
                            zend_hash_index_del(type->attributes, index);
                     }
              }
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int schema_union ( sdlPtr  sdl,
xmlAttrPtr  tns,
xmlNodePtr  unionType,
sdlTypePtr  cur_type 
) [static]

Definition at line 493 of file php_schema.c.

{
       xmlNodePtr trav;
       xmlAttrPtr memberTypes;

       memberTypes = get_attribute(unionType->properties, "memberTypes");
       if (memberTypes != NULL) {
              char *str, *start, *end, *next;
              char *type, *ns;
              xmlNsPtr nsptr;

              str = estrdup((char*)memberTypes->children->content);
              whiteSpace_collapse(BAD_CAST(str));
              start = str;
              while (start != NULL && *start != '\0') {
                     end = strchr(start,' ');
                     if (end == NULL) {
                            next = NULL;
                     } else {
                            *end = '\0';
                            next = end+1;
                     }

                     parse_namespace(BAD_CAST(start), &type, &ns);
                     nsptr = xmlSearchNs(unionType->doc, unionType, BAD_CAST(ns));
                     if (nsptr != NULL) {
                            sdlTypePtr newType, *tmp;

                            newType = emalloc(sizeof(sdlType));
                            memset(newType, 0, sizeof(sdlType));

                            newType->name = estrdup(type);
                            newType->namens = estrdup((char*)nsptr->href);

                            newType->encode = get_create_encoder(sdl, newType, nsptr->href, BAD_CAST(type));

                            if (cur_type->elements == NULL) {
                                   cur_type->elements = emalloc(sizeof(HashTable));
                                   zend_hash_init(cur_type->elements, 0, NULL, delete_type, 0);
                            }
                            zend_hash_next_index_insert(cur_type->elements, &newType, sizeof(sdlTypePtr), (void **)&tmp);
                     }
                     if (type) {efree(type);}
                     if (ns) {efree(ns);}

                     start = next;
              }
              efree(str);
       }

       trav = unionType->children;
       if (trav != NULL && node_is_equal(trav,"annotation")) {
              /* TODO: <annotation> support */
              trav = trav->next;
       }
       while (trav != NULL) {
              if (node_is_equal(trav,"simpleType")) {
                     sdlTypePtr newType, *tmp;

                     newType = emalloc(sizeof(sdlType));
                     memset(newType, 0, sizeof(sdlType));

                     {
                            smart_str anonymous = {0};
                     
                            smart_str_appendl(&anonymous, "anonymous", sizeof("anonymous")-1);
                            smart_str_append_long(&anonymous, zend_hash_num_elements(sdl->types));
                            smart_str_0(&anonymous);
                            newType->name = anonymous.c;
                     }
                     newType->namens = estrdup((char*)tns->children->content);

                     if (cur_type->elements == NULL) {
                            cur_type->elements = emalloc(sizeof(HashTable));
                            zend_hash_init(cur_type->elements, 0, NULL, delete_type, 0);
                     }
                     zend_hash_next_index_insert(cur_type->elements, &newType, sizeof(sdlTypePtr), (void **)&tmp);

                     schema_simpleType(sdl, tns, trav, newType);

              } else {
                     soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in union", trav->name);
              }
              trav = trav->next;
       }
       if (trav != NULL) {
              soap_error1(E_ERROR, "Parsing Schema: unexpected <%s> in union", trav->name);
       }
       return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function: