diff GEMBASSY-1.0.3/gsoap/wsdl/schema.cpp @ 2:8947fca5f715 draft default tip

Uploaded

--- a/GEMBASSY-1.0.3/gsoap/wsdl/schema.cpp	Fri Jun 26 05:20:29 2015 -0400
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1699 +0,0 @@
-/*
-	schema.cpp
-
-	XSD binding schema implementation
-
---------------------------------------------------------------------------------
-gSOAP XML Web services tools
-Copyright (C) 2000-2012, Robert van Engelen, Genivia Inc. All Rights Reserved.
-This software is released under one of the following licenses:
-GPL or Genivia's license for commercial use.
---------------------------------------------------------------------------------
-GPL license.
-
-This program is free software; you can redistribute it and/or modify it under
-the terms of the GNU General Public License as published by the Free Software
-Foundation; either version 2 of the License, or (at your option) any later
-version.
-
-This program is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with
-this program; if not, write to the Free Software Foundation, Inc., 59 Temple
-Place, Suite 330, Boston, MA 02111-1307 USA
-
-Author contact information:
[e-mail] / [e-mail]
---------------------------------------------------------------------------------
-A commercial use license is available from Genivia, Inc., [e-mail]
---------------------------------------------------------------------------------
-
-*/
-
-#include "wsdlH.h"		// cannot include "schemaH.h"
-#include "includes.h"
-
-extern struct Namespace namespaces[];
-
-extern "C" {
-extern int warn_ignore(struct soap*, const char*);
-}
-
-extern const char *qname_token(const char*, const char*);
-extern int is_builtin_qname(const char*);
-
-////////////////////////////////////////////////////////////////////////////////
-//
-//	schema
-//
-////////////////////////////////////////////////////////////////////////////////
-
-xs__schema::xs__schema()
-{ soap = soap_new1(SOAP_XML_TREE | SOAP_C_UTFSTRING);
-#ifdef HTTPDA_H
-  soap_register_plugin(soap, http_da);
-#endif
-#ifdef WITH_OPENSSL
-  soap_ssl_client_context(soap, SOAP_SSL_NO_AUTHENTICATION, NULL, NULL, NULL, NULL, NULL);
-#endif
-  soap_set_namespaces(soap, namespaces);
-  soap_default(soap);
-  soap->fignore = warn_ignore;
-  soap->encodingStyle = NULL;
-  soap->proxy_host = proxy_host;
-  soap->proxy_port = proxy_port;
-  soap->proxy_userid = proxy_userid;
-  soap->proxy_passwd = proxy_passwd;
-  targetNamespace = NULL;
-  version = NULL;
-  updated = false;
-  location = NULL;
-  redirs = 0;
-}
-
-xs__schema::xs__schema(struct soap *copy)
-{ soap = soap_copy(copy);
-  soap->socket = SOAP_INVALID_SOCKET;
-  soap->recvfd = 0;
-  soap->sendfd = 1;
-  soap_default(soap);
-  soap->fignore = warn_ignore;
-  soap->encodingStyle = NULL;
-  targetNamespace = NULL;
-  version = NULL;
-  updated = false;
-  location = NULL;
-  redirs = 0;
-}
-
-xs__schema::xs__schema(struct soap *copy, const char *cwd, const char *loc)
-{ soap = soap_copy(copy);
-  soap->socket = SOAP_INVALID_SOCKET;
-  soap->recvfd = 0;
-  soap->sendfd = 1;
-  /* no longer required, since we keep the host name:
-  strcpy(soap->host, copy->host);
-  */
-  soap_default(soap);
-  soap->fignore = warn_ignore;
-  soap->encodingStyle = NULL;
-  targetNamespace = NULL;
-  version = NULL;
-  updated = false;
-  location = NULL;
-  redirs = 0;
-  read(cwd, loc);
-}
-
-xs__schema::~xs__schema()
-{ }
-
-int xs__schema::get(struct soap *soap)
-{ return preprocess();
-}
-
-int xs__schema::preprocess()
-{ // process xs:include recursively
-  // NOTE: includes are context sensitive (take context info), so keep including
-  for (vector<xs__include>::iterator in = include.begin(); in != include.end(); ++in)
-  { (*in).preprocess(*this); // read schema and recurse over <include>
-    if ((*in).schemaPtr())
-      insert(*(*in).schemaPtr());
-  }
-  for (vector<xs__redefine>::iterator re = redefine.begin(); re != redefine.end(); ++re)
-  { (*re).preprocess(*this); // read schema and recurse over <redefine>
-    if ((*re).schemaPtr())
-      insert(*(*re).schemaPtr());
-  }
-  return SOAP_OK;
-}
-
-int xs__schema::insert(xs__schema& schema)
-{ bool found;
-  if (targetNamespace && schema.targetNamespace && strcmp(targetNamespace, schema.targetNamespace))
-    if (!Wflag)
-      fprintf(stderr, "Warning: attempt to include schema with mismatching targetNamespace '%s' in schema '%s'\n", schema.targetNamespace, targetNamespace);
-  if (elementFormDefault != schema.elementFormDefault)
-    if (!Wflag)
-      fprintf(stderr, "Warning: attempt to include schema with mismatching elementFormDefault in schema '%s'\n", targetNamespace?targetNamespace:"");
-  if (attributeFormDefault != schema.attributeFormDefault)
-    if (!Wflag)
-      fprintf(stderr, "Warning: attempt to include schema with mismatching attributeFormDefault in schema '%s'\n", targetNamespace?targetNamespace:"");
-  // insert imports, but only add imports with new namespace
-  for (vector<xs__import>::const_iterator im = schema.import.begin(); im != schema.import.end(); ++im)
-  { found = false;
-    if ((*im).namespace_)
-    { for (vector<xs__import>::const_iterator i = import.begin(); i != import.end(); ++i)
-      { if ((*i).namespace_ && !strcmp((*im).namespace_, (*i).namespace_))
-        { found = true;
-          break;
-        }
-      }
-    }
-    if (!found)
-      import.push_back(*im);
-  }
-  // insert attributes, but only add attributes with new name (limited conflict check)
-  for (vector<xs__attribute>::const_iterator at = schema.attribute.begin(); at != schema.attribute.end(); ++at)
-  { found = false;
-    if ((*at).name)
-    { for (vector<xs__attribute>::const_iterator a = attribute.begin(); a != attribute.end(); ++a)
-      { if ((*a).name && !strcmp((*at).name, (*a).name))
-        { found = true;
-          if ((*at).type && (*a).type && strcmp((*at).type, (*a).type))
-            if (!Wflag)
-	      fprintf(stderr, "Warning: attempt to redefine attribute '%s' with type '%s' in schema '%s'\n", (*at).name, (*at).type, targetNamespace?targetNamespace:"");
-          break;
-        }
-      }
-    }
-    if (!found)
-    { attribute.push_back(*at);
-      attribute.back().schemaPtr(this);
-    }
-  }
-  // insert elements, but only add elements with new name (limited conflict check)
-  for (vector<xs__element>::const_iterator el = schema.element.begin(); el != schema.element.end(); ++el)
-  { found = false;
-    if ((*el).name)
-    { for (vector<xs__element>::const_iterator e = element.begin(); e != element.end(); ++e)
-      { if ((*e).name && !strcmp((*el).name, (*e).name))
-        { found = true;
-          if ((*el).type && (*e).type && strcmp((*el).type, (*e).type))
-            if (!Wflag)
-	      fprintf(stderr, "Warning: attempt to redefine element '%s' with type '%s' in schema '%s'\n", (*el).name, (*el).type, targetNamespace?targetNamespace:"");
-          break;
-        }
-      }
-    }
-    if (!found)
-    { element.push_back(*el);
-      element.back().schemaPtr(this);
-    }
-  }
-  // insert groups, but only add groups with new name (no conflict check)
-  for (vector<xs__group>::const_iterator gp = schema.group.begin(); gp != schema.group.end(); ++gp)
-  { found = false;
-    if ((*gp).name)
-    { for (vector<xs__group>::const_iterator g = group.begin(); g != group.end(); ++g)
-      { if ((*g).name && !strcmp((*gp).name, (*g).name))
-        { found = true;
-          break;
-        }
-      }
-    }
-    if (!found)
-    { group.push_back(*gp);
-      group.back().schemaPtr(this);
-    }
-  }
-  // insert attributeGroups, but only add attributeGroups with new name (no conflict check)
-  for (vector<xs__attributeGroup>::const_iterator ag = schema.attributeGroup.begin(); ag != schema.attributeGroup.end(); ++ag)
-  { found = false;
-    if ((*ag).name)
-    { for (vector<xs__attributeGroup>::const_iterator g = attributeGroup.begin(); g != attributeGroup.end(); ++g)
-      { if ((*g).name && !strcmp((*ag).name, (*g).name))
-        { found = true;
-          break;
-        }
-      }
-    }
-    if (!found)
-    { attributeGroup.push_back(*ag);
-      attributeGroup.back().schemaPtr(this);
-    }
-  }
-  // insert simpleTypes, but only add simpleTypes with new name (no conflict check)
-  for (vector<xs__simpleType>::const_iterator st = schema.simpleType.begin(); st != schema.simpleType.end(); ++st)
-  { found = false;
-    if ((*st).name)
-    { for (vector<xs__simpleType>::const_iterator s = simpleType.begin(); s != simpleType.end(); ++s)
-      { if ((*s).name && !strcmp((*st).name, (*s).name))
-        { found = true;
-          break;
-        }
-      }
-    }
-    if (!found)
-    { simpleType.push_back(*st);
-      simpleType.back().schemaPtr(this);
-    }
-  }
-  // insert complexTypes, but only add complexTypes with new name (no conflict check)
-  for (vector<xs__complexType>::const_iterator ct = schema.complexType.begin(); ct != schema.complexType.end(); ++ct)
-  { found = false;
-    if ((*ct).name)
-    { for (vector<xs__complexType>::const_iterator c = complexType.begin(); c != complexType.end(); ++c)
-      { if ((*c).name && !strcmp((*ct).name, (*c).name))
-        { found = true;
-          break;
-        }
-      }
-    }
-    if (!found)
-    { complexType.push_back(*ct);
-      complexType.back().schemaPtr(this);
-    }
-  }
-  return SOAP_OK;
-}
-
-int xs__schema::traverse()
-{ if (updated)
-    return SOAP_OK;
-  if (vflag)
-    cerr << "  Analyzing schema '" << (targetNamespace?targetNamespace:"") << "'" << endl;
-  updated = true;
-  if (!targetNamespace)
-  { if (vflag)
-      fprintf(stderr, "Warning: Schema has no targetNamespace\n");
-    targetNamespace = soap_strdup(soap, "");
-  }
-  else if (exturis.find(targetNamespace) != exturis.end())
-  { if (vflag)
-      fprintf(stderr, "Warning: Built-in schema '%s' content encountered\n", targetNamespace);
-  }
-  // process import
-  for (vector<xs__import>::iterator im = import.begin(); im != import.end(); ++im)
-    (*im).traverse(*this);
-  // process attributes
-  for (vector<xs__attribute>::iterator at = attribute.begin(); at != attribute.end(); ++at)
-    (*at).traverse(*this);
-  // process elements
-  for (vector<xs__element>::iterator el = element.begin(); el != element.end(); 
-++el)
-    (*el).traverse(*this);
-  // process simpleTypes, check conflicts with complexTypes
-  for (vector<xs__simpleType>::iterator st = simpleType.begin(); st != simpleType.end(); ++st)
-  { (*st).traverse(*this);
-    if ((*st).name)
-    { for (vector<xs__complexType>::iterator ct = complexType.begin(); ct != complexType.end(); ++ct)
-        if ((*ct).name && !strcmp((*st).name, (*ct).name))
-          if (!Wflag)
-	    fprintf(stderr, "Warning: top-level simpleType name and complexType name '%s' clash in schema '%s'\n", (*st).name, targetNamespace?targetNamespace:"");
-    }
-  }
-  // process complexTypes
-  for (vector<xs__complexType>::iterator ct = complexType.begin(); ct != complexType.end(); ++ct)
-    (*ct).traverse(*this);
-  // process groups
-  for (vector<xs__group>::iterator gp = group.begin(); gp != group.end(); ++gp)
-    (*gp).traverse(*this);
-  // process attributeGroups
-  for (vector<xs__attributeGroup>::iterator ag = attributeGroup.begin(); ag != attributeGroup.end(); ++ag)
-    (*ag).traverse(*this);
-  if (vflag)
-    cerr << "  End of schema '" << (targetNamespace?targetNamespace:"") << "'" << endl;
-  return SOAP_OK;
-}
-
-int xs__schema::read(const char *cwd, const char *loc)
-{ const char *cwd_temp;
-  if (!cwd)
-    cwd = cwd_path;
-  if (vflag)
-    fprintf(stderr, "\nOpening schema '%s' from '%s'\n", loc?loc:"", cwd?cwd:"");
-  if (loc)
-  { if (soap->recvfd > 2)
-    { soap_end_recv(soap);
-      close(soap->recvfd);
-      soap->recvfd = -1;
-    }
-    else if (soap_valid_socket(soap->socket))
-    { soap_end_recv(soap);
-      soap_closesock(soap);
-    }
-#ifdef WITH_OPENSSL
-    if (!strncmp(loc, "http://", 7) || !strncmp(loc, "https://", 8))
-#else
-    if (!strncmp(loc, "https://", 8))
-    { fprintf(stderr, "\nCannot connect to https site: no SSL support, please rebuild with SSL (default) or download the files and rerun wsdl2h\n");
-      exit(1);
-    }
-    else if (!strncmp(loc, "http://", 7))
-#endif
-    { fprintf(stderr, "\nConnecting to '%s' to retrieve schema...\n", loc);
-      location = soap_strdup(soap, loc);
-      if (soap_connect_command(soap, SOAP_GET, location, NULL))
-      { fprintf(stderr, "\nConnection failed\n");
-        exit(1);
-      }
-      fprintf(stderr, "Connected, receiving...\n");
-    }
-    else if (cwd && (!strncmp(cwd, "http://", 7) || !strncmp(cwd, "https://", 8)))
-    { char *s;
-      location = (char*)soap_malloc(soap, strlen(cwd) + strlen(loc) + 2);
-      strcpy(location, cwd);
-      s = strrchr(location, '/');
-      if (s)
-        *s = '\0';
-      strcat(location, "/");
-      strcat(location, loc);
-      fprintf(stderr, "\nConnecting to '%s' to retrieve relative path '%s' schema...\n", location, loc);
-      if (soap_connect_command(soap, SOAP_GET, location, NULL))
-      { fprintf(stderr, "\nConnection failed\n");
-        exit(1);
-      }
-      fprintf(stderr, "Connected, receiving...\n");
-    }
-    else
-    { soap->recvfd = open(loc, O_RDONLY, 0);
-      if (soap->recvfd < 0)
-      { if (cwd)
-        { char *s;
-          location = (char*)soap_malloc(soap, strlen(cwd) + strlen(loc) + 2);
-          strcpy(location, cwd);
-          s = strrchr(location, '/');
-#ifdef WIN32
-          if (!s)
-            s = strrchr(location, '\\');
-#endif
-          if (s)
-            *s = '\0';
-          strcat(location, "/");
-          strcat(location, loc);
-          if (!strncmp(location, "file://", 7))
-            location += 7;
-          soap->recvfd = open(location, O_RDONLY, 0);
-        }
-        if (soap->recvfd < 0 && import_path)
-        { location = (char*)soap_malloc(soap, strlen(import_path) + strlen(loc) + 2);
-          strcpy(location, import_path);
-          strcat(location, "/");
-          strcat(location, loc);
-          if (!strncmp(location, "file://", 7))
-            location += 7;
-          soap->recvfd = open(location, O_RDONLY, 0);
-        }
-        if (soap->recvfd < 0)
-        { fprintf(stderr, "\nCannot open '%s' to retrieve schema\n", loc);
-          exit(1);
-        }
-      }
-      else
-        location = soap_strdup(soap, loc);
-      fprintf(stderr, "\nReading schema file '%s'...\n", location);
-    }
-  }
-  cwd_temp = cwd_path;
-  cwd_path = location;
-  if (!soap_begin_recv(soap))
-    this->soap_in(soap, "xs:schema", NULL);
-  if ((soap->error >= 301 && soap->error <= 303) || soap->error == 307) // HTTP redirect, socket was closed
-  { int r = SOAP_ERR;
-    fprintf(stderr, "Redirected to '%s'...\n", soap->endpoint);
-    if (redirs++ < 10)
-      r = read(cwd, soap->endpoint);
-    else
-      fprintf(stderr, "\nMax redirects exceeded\n");
-    redirs--;
-    return r;
-  }
-  else if (soap->error == 401)
-  { int r = SOAP_ERR;
-    fprintf(stderr, "Authenticating to '%s' realm '%s'...\n", loc, soap->authrealm);
-    if (auth_userid && auth_passwd && redirs++ < 1)
-    { 
-#ifdef HTTPDA_H
-      struct http_da_info info;
-      http_da_save(soap, &info, soap->authrealm, auth_userid, auth_passwd);
-#else
-      soap->userid = auth_userid;
-      soap->passwd = auth_passwd;
-#endif
-      r = read(cwd, loc);
-#ifdef HTTPDA_H
-      http_da_release(soap, &info);
-#endif
-      redirs--;
-    }
-    else
-      fprintf(stderr, "Authentication failed, use option -r:uid:pwd and (re)build with OpenSSL to enable digest authentication\n");
-    return r;
-  }
-  if (soap->error)
-  { fprintf(stderr, "\nAn error occurred while parsing schema from '%s'\n", loc?loc:"");
-    soap_print_fault(soap, stderr);
-    if (soap->error < 200)
-      soap_print_fault_location(soap, stderr);
-    fprintf(stderr, "\nIf this schema namespace is considered \"built-in\", then add\n  namespaceprefix = <namespaceURI>\nto typemap.dat.\n");
-    exit(1);
-  }
-  fprintf(stderr, "Done reading '%s'\n", loc?loc:"");
-  soap_end_recv(soap);
-  if (soap->recvfd > 2)
-  { close(soap->recvfd);
-    soap->recvfd = -1;
-  }
-  else
-    soap_closesock(soap);
-  cwd_path = cwd_temp;
-  return SOAP_OK;
-}
-
-void xs__schema::sourceLocation(const char *loc)
-{ location = soap_strdup(soap, loc);
-}
-
-const char *xs__schema::sourceLocation()
-{ return location;
-}
-
-int xs__schema::error()
-{ return soap->error;
-}
-
-void xs__schema::print_fault()
-{ soap_print_fault(soap, stderr);
-  if (soap->error < 200)
-    soap_print_fault_location(soap, stderr);
-}
-
-void xs__schema::builtinType(const char *type)
-{ builtinTypeSet.insert(type);
-}
-
-void xs__schema::builtinElement(const char *element)
-{ builtinElementSet.insert(element);
-}
-
-void xs__schema::builtinAttribute(const char *attribute)
-{ builtinAttributeSet.insert(attribute);
-}
-
-const SetOfString& xs__schema::builtinTypes() const
-{ return builtinTypeSet;
-}
-
-const SetOfString& xs__schema::builtinElements() const
-{ return builtinElementSet;
-}
-
-const SetOfString& xs__schema::builtinAttributes() const
-{ return builtinAttributeSet;
-}
-
-bool xs__schema::empty() const
-{ return include.empty() && redefine.empty() && import.empty() && attribute.empty() && element.empty() && group.empty() && attributeGroup.empty() && simpleType.empty() && complexType.empty();
-}
-
-xs__include::xs__include()
-{ schemaLocation = NULL;
-  schemaRef = NULL;
-}
-
-int xs__include::preprocess(xs__schema &schema)
-{ if (!schemaRef && schemaLocation)
-  { // only read from include locations not read already, uses static std::map
-    static map<const char*, xs__schema*, ltstr> included;
-    map<const char*, xs__schema*, ltstr>::iterator i = included.end();
-    if (schema.targetNamespace)
-      for (i = included.begin(); i != included.end(); ++i)
-        if ((*i).second->targetNamespace
-         && !strcmp(schemaLocation, (*i).first)
-         && !strcmp(schema.targetNamespace, (*i).second->targetNamespace))
-          break;
-    if (i == included.end())
-    { if (vflag)
-        cerr << "Preprocessing schema include '" << (schemaLocation?schemaLocation:"") << "' into schema '" << (schema.targetNamespace?schema.targetNamespace:"") << "'" << endl;
-      included[schemaLocation] = schemaRef = new xs__schema(schema.soap);
-      schemaRef->read(schema.sourceLocation(), schemaLocation);
-      schemaRef->targetNamespace = schema.targetNamespace;
-    }
-    else
-    { if (vflag)
-        cerr << "Schema '" << (schemaLocation?schemaLocation:"") << "' already included into schema '" << (schema.targetNamespace?schema.targetNamespace:"") << "'" << endl;
-      schemaRef = (*i).second;
-    }
-  }
-  return SOAP_OK;
-}
-
-int xs__include::traverse(xs__schema &schema)
-{ return SOAP_OK;
-}
-
-void xs__include::schemaPtr(xs__schema *schema)
-{ schemaRef = schema;
-}
-
-xs__schema *xs__include::schemaPtr() const
-{ return schemaRef;
-}
-
-xs__redefine::xs__redefine()
-{ schemaLocation = NULL;
-  schemaRef = NULL;
-}
-
-int xs__redefine::preprocess(xs__schema &schema)
-{ if (vflag)
-    cerr << "Preprocessing schema redefine '" << (schemaLocation?schemaLocation:"") << "' into schema '" << (schema.targetNamespace?schema.targetNamespace:"") << "'" << endl;
-  if (!schemaRef)
-  { if (schemaLocation)
-    { schemaRef = new xs__schema(schema.soap, schema.sourceLocation(), schemaLocation);
-      for (vector<xs__group>::iterator gp = schemaRef->group.begin(); gp != schemaRef->group.end(); ++gp)
-      { if ((*gp).name)
-        { for (vector<xs__group>::const_iterator g = group.begin(); g != group.end(); ++g)
-          { if ((*g).name && !strcmp((*gp).name, (*g).name))
-            { *gp = *g;
-              break;
-            }
-          }
-        }
-      }
-      for (vector<xs__attributeGroup>::iterator ag = schemaRef->attributeGroup.begin(); ag != schemaRef->attributeGroup.end(); ++ag)
-      { if ((*ag).name)
-        { for (vector<xs__attributeGroup>::const_iterator g = attributeGroup.begin(); g != attributeGroup.end(); ++g)
-          { if ((*g).name && !strcmp((*ag).name, (*g).name))
-            { *ag = *g;
-              break;
-            }
-          }
-        }
-      }
-      for (vector<xs__simpleType>::iterator st = schemaRef->simpleType.begin(); st != schemaRef->simpleType.end(); ++st)
-      { if ((*st).name)
-        { for (vector<xs__simpleType>::const_iterator s = simpleType.begin(); s != simpleType.end(); ++s)
-          { if ((*s).name && !strcmp((*st).name, (*s).name))
-            { *st = *s;
-              break;
-            }
-          }
-        }
-      }
-      for (vector<xs__complexType>::iterator ct = schemaRef->complexType.begin(); ct != schemaRef->complexType.end(); ++ct)
-      { if ((*ct).name)
-        { for (vector<xs__complexType>::const_iterator c = complexType.begin(); c != complexType.end(); ++c)
-          { if ((*c).name && !strcmp((*ct).name, (*c).name))
-            { *ct = *c;
-              break;
-            }
-          }
-        }
-      }
-    }
-  }
-  return SOAP_OK;
-}
-
-int xs__redefine::traverse(xs__schema &schema)
-{ return SOAP_OK;
-}
-
-void xs__redefine::schemaPtr(xs__schema *schema)
-{ schemaRef = schema;
-}
-
-xs__schema *xs__redefine::schemaPtr() const
-{ return schemaRef;
-}
-
-xs__import::xs__import()
-{ namespace_ = NULL;
-  schemaLocation = NULL;
-  schemaRef = NULL;
-}
-
-int xs__import::traverse(xs__schema &schema)
-{ if (vflag)
-    cerr << "   Analyzing schema import '" << (namespace_?namespace_:"") << "'" << endl;
-  if (!schemaRef)
-  { bool found = false;
-    if (namespace_)
-    { for (SetOfString::const_iterator i = exturis.begin(); i != exturis.end(); ++i)
-      { if (!soap_tag_cmp(namespace_, *i))
-        { found = true;
-          break;
-        }
-      }
-    }
-    else if (!Wflag)
-      fprintf(stderr, "Warning: no namespace in <import>\n");
-    if (!found && !iflag) // don't import any of the schemas in the .nsmap table (or when -i option is used)
-    { const char *s = schemaLocation;
-      if (!s)
-        s = namespace_;
-      // only read from import locations not read already, uses static std::map
-      static map<const char*, xs__schema*, ltstr> included;
-      map<const char*, xs__schema*, ltstr>::iterator i = included.find(s);
-      if (i == included.end())
-      { included[s] = schemaRef = new xs__schema(schema.soap);
-        schemaRef->read(schema.sourceLocation(), s);
-      }
-      else
-        schemaRef = (*i).second;
-      if (schemaRef)
-      { if (!schemaRef->targetNamespace || !*schemaRef->targetNamespace)
-          schemaRef->targetNamespace = namespace_;
-        else
-	  if (!namespace_ || strcmp(schemaRef->targetNamespace, namespace_))
-            if (!Wflag)
-	      fprintf(stderr, "Warning: schema import '%s' with schema targetNamespace '%s' mismatch\n", namespace_?namespace_:"", schemaRef->targetNamespace);
-      }
-    }
-  }
-  if (schemaRef)
-    schemaRef->traverse();
-  return SOAP_OK;
-}
-
-void xs__import::schemaPtr(xs__schema *schema)
-{ schemaRef = schema;
-}
-
-xs__schema *xs__import::schemaPtr() const
-{ return schemaRef;
-}
-
-xs__attribute::xs__attribute()
-{ schemaRef = NULL;
-  attributeRef = NULL;
-  simpleTypeRef = NULL;
-}
-
-int xs__attribute::traverse(xs__schema &schema)
-{ if (vflag)
-    cerr << "   Analyzing schema attribute '" << (name?name:"") << "'" << endl;
-  schemaRef = &schema;
-  const char *token = qname_token(ref, schema.targetNamespace);
-  attributeRef = NULL;
-  if (token)
-  { for (vector<xs__attribute>::iterator i = schema.attribute.begin(); i != schema.attribute.end(); ++i)
-      if (!strcmp((*i).name, token))
-      { attributeRef = &(*i);
-        if (vflag)
-          cerr << "    Found attribute '" << (name?name:"") << "' ref '" << (token?token:"") << "'" << endl;
-        break;
-      }
-  }
-  if (!attributeRef)
-  { for (vector<xs__import>::iterator i = schema.import.begin(); i != schema.import.end(); ++i)
-    { xs__schema *s = (*i).schemaPtr();
-      if (s)
-      { token = qname_token(ref, s->targetNamespace);
-        if (token)
-        { for (vector<xs__attribute>::iterator j = s->attribute.begin(); j != s->attribute.end(); ++j)
-          { if (!strcmp((*j).name, token))
-            { attributeRef = &(*j);
-              if (vflag)
-                cerr << "    Found attribute '" << (name?name:"") << "' ref '" << (token?token:"") << "'" << endl;
-              break;
-            }
-	  }
-          if (attributeRef)
-	    break;
-        }
-      }
-    }
-  }
-  if (simpleType)
-  { simpleType->traverse(schema);
-    simpleTypeRef = simpleType;
-  }
-  else
-  { token = qname_token(type, schema.targetNamespace);
-    simpleTypeRef = NULL;
-    if (token)
-    { for (vector<xs__simpleType>::iterator i = schema.simpleType.begin(); i != schema.simpleType.end(); ++i)
-        if (!strcmp((*i).name, token))
-        { simpleTypeRef = &(*i);
-          if (vflag)
-            cerr << "    Found attribute '" << (name?name:"") << "' type '" << (token?token:"") << "'" << endl;
-          break;
-        }
-    }
-    if (!simpleTypeRef)
-    { for (vector<xs__import>::iterator i = schema.import.begin(); i != schema.import.end(); ++i)
-      { xs__schema *s = (*i).schemaPtr();
-        if (s)
-        { token = qname_token(type, s->targetNamespace);
-          if (token)
-          { for (vector<xs__simpleType>::iterator j = s->simpleType.begin(); j != s->simpleType.end(); ++j)
-            { if (!strcmp((*j).name, token))
-              { simpleTypeRef = &(*j);
-                if (vflag)
-                  cerr << "    Found attribute '" << (name?name:"") << "' type '" << (token?token:"") << "'" << endl;
-                break;
-              }
-	    }
-	    if (simpleTypeRef)
-              break;
-          }
-        }
-      }
-    }
-  }
-  if (!attributeRef && !simpleTypeRef)
-  { if (ref)
-    { if (is_builtin_qname(ref))
-        schema.builtinAttribute(ref);
-      else if (!Wflag)
-	cerr << "Warning: could not find attribute '" << (name?name:"") << "' ref '" << ref << "' in schema '" << (schema.targetNamespace?schema.targetNamespace:"") << "'" << endl;
-    }
-    else if (type)
-    { if (is_builtin_qname(type))
-        schema.builtinType(type);
-      else if (!Wflag)
-	cerr << "Warning: could not find attribute '" << (name?name:"") << "' type '" << type << "' in schema '" << (schema.targetNamespace?schema.targetNamespace:"") << "'" << endl;
-    }
-  }
-  return SOAP_OK;
-}
-
-void xs__attribute::schemaPtr(xs__schema *schema)
-{ schemaRef = schema;
-}
-
-xs__schema* xs__attribute::schemaPtr() const
-{ return schemaRef;
-}
-
-void xs__attribute::attributePtr(xs__attribute *attribute)
-{ attributeRef = attribute;
-}
-
-void xs__attribute::simpleTypePtr(xs__simpleType *simpleType)
-{ simpleTypeRef = simpleType;
-}
-
-xs__attribute *xs__attribute::attributePtr() const
-{ return attributeRef;
-}
-
-xs__simpleType *xs__attribute::simpleTypePtr() const
-{ return simpleTypeRef;
-}
-
-xs__element::xs__element()
-{ schemaRef = NULL;
-  elementRef = NULL;
-  simpleTypeRef = NULL;
-  complexTypeRef = NULL;
-}
-
-int xs__element::traverse(xs__schema &schema)
-{ if (vflag)
-    cerr << "   Analyzing schema element '" << (name?name:"") << "'" << endl;
-  schemaRef = &schema;
-  const char *token = qname_token(ref, schema.targetNamespace);
-  elementRef = NULL;
-  if (token)
-  { for (vector<xs__element>::iterator i = schema.element.begin(); i != schema.element.end(); ++i)
-    { if ((*i).name && !strcmp((*i).name, token))
-      { elementRef = &(*i);
-        if (vflag)
-          cerr << "    Found element '" << (name?name:"") << "' ref '" << (token?token:"") << "'" << endl;
-        break;
-      }
-    }
-  }
-  if (!elementRef)
-  { for (vector<xs__import>::const_iterator i = schema.import.begin(); i != schema.import.end(); ++i)
-    { xs__schema *s = (*i).schemaPtr();
-      if (s)
-      { token = qname_token(ref, s->targetNamespace);
-        if (token)
-        { for (vector<xs__element>::iterator j = s->element.begin(); j != s->element.end(); ++j)
-          { if ((*j).name && !strcmp((*j).name, token))
-            { elementRef = &(*j);
-              if (vflag)
-                cerr << "    Found element '" << (name?name:"") << "' ref '" << (token?token:"") << "'" << endl;
-              break;
-            }
-          }
-	  if (elementRef)
-            break;
-        }
-      }
-    }
-  }
-  if (simpleType)
-  { simpleType->traverse(schema);
-    simpleTypeRef = simpleType;
-  }
-  else
-  { token = qname_token(type, schema.targetNamespace);
-    simpleTypeRef = NULL;
-    if (token)
-    { for (vector<xs__simpleType>::iterator i = schema.simpleType.begin(); i != schema.simpleType.end(); ++i)
-        if ((*i).name && !strcmp((*i).name, token))
-        { simpleTypeRef = &(*i);
-          if (vflag)
-            cerr << "    Found element '" << (name?name:"") << "' simpleType '" << (token?token:"") << "'" << endl;
-          break;
-        }
-    }
-    if (!simpleTypeRef)
-    { for (vector<xs__import>::const_iterator i = schema.import.begin(); i != schema.import.end(); ++i)
-      { xs__schema *s = (*i).schemaPtr();
-        if (s)
-        { token = qname_token(type, s->targetNamespace);
-          if (token)
-          { for (vector<xs__simpleType>::iterator j = s->simpleType.begin(); j != s->simpleType.end(); ++j)
-            { if ((*j).name && !strcmp((*j).name, token))
-              { simpleTypeRef = &(*j);
-                if (vflag)
-                  cerr << "    Found element '" << (name?name:"") << "' simpleType '" << (token?token:"") << "'" << endl;
-                break;
-              }
-            }
-	    if (simpleTypeRef)
-              break;
-          }
-        }
-      }
-    }
-  }
-  if (complexType)
-  { complexType->traverse(schema);
-    complexTypeRef = complexType;
-  }
-  else
-  { token = qname_token(type, schema.targetNamespace);
-    complexTypeRef = NULL;
-    if (token)
-    { for (vector<xs__complexType>::iterator i = schema.complexType.begin(); i != schema.complexType.end(); ++i)
-        if ((*i).name && !strcmp((*i).name, token))
-        { complexTypeRef = &(*i);
-          if (vflag)
-            cerr << "    Found element '" << (name?name:"") << "' complexType '" << (token?token:"") << "'" << endl;
-          break;
-        }
-    }
-    if (!complexTypeRef)
-    { for (vector<xs__import>::const_iterator i = schema.import.begin(); i != schema.import.end(); ++i)
-      { xs__schema *s = (*i).schemaPtr();
-        if (s)
-        { token = qname_token(type, s->targetNamespace);
-          if (token)
-          { for (vector<xs__complexType>::iterator j = s->complexType.begin(); j != s->complexType.end(); ++j)
-            { if ((*j).name && !strcmp((*j).name, token))
-              { complexTypeRef = &(*j);
-                if (vflag)
-                  cerr << "    Found element '" << (name?name:"") << "' complexType '" << (token?token:"") << "'" << endl;
-                break;
-              }
-            }
-	    if (complexTypeRef)
-              break;
-          }
-        }
-      }
-    }
-  }
-  token = qname_token(substitutionGroup, schema.targetNamespace);
-  if (token)
-  { for (vector<xs__element>::iterator i = schema.element.begin(); i != schema.element.end(); ++i)
-      if (!strcmp((*i).name, token))
-      { (*i).substitutions.push_back(this);
-        if (vflag)
-          cerr << "    Found substitutionGroup element '" << (name?name:"") << "' for abstract element '" << (token?token:"") << "'" << endl;
-        break;
-      }
-  }
-  for (vector<xs__import>::const_iterator i = schema.import.begin(); i != schema.import.end(); ++i)
-  { xs__schema *s = (*i).schemaPtr();
-    if (s)
-    { token = qname_token(substitutionGroup, s->targetNamespace);
-      if (token)
-      { for (vector<xs__element>::iterator j = s->element.begin(); j != s->element.end(); ++j)
-        { if (!strcmp((*j).name, token))
-          { (*j).substitutions.push_back(this);
-            if (vflag)
-              cerr << "    Found substitutionGroup element '" << (name?name:"") << "' for abstract element '" << (token?token:"") << "'" << endl;
-            break;
-          }
-        }
-      }
-    }
-  }
-  if (!elementRef && !simpleTypeRef && !complexTypeRef)
-  { if (ref)
-    { if (is_builtin_qname(ref))
-        schema.builtinElement(ref);
-      else if (!Wflag)
-	cerr << "Warning: could not find element '" << (name?name:"") << "' ref '" << ref << "' in schema '" << (schema.targetNamespace?schema.targetNamespace:"") << "'" << endl;
-    }
-    else if (type)
-    { if (is_builtin_qname(type))
-        schema.builtinType(type);
-      else if (!Wflag)
-	cerr << "Warning: could not find element '" << (name?name:"") << "' type '" << type << "' in schema '" << (schema.targetNamespace?schema.targetNamespace:"") << "'" << endl;
-    }
-  }
-  return SOAP_OK;
-}
-
-void xs__element::schemaPtr(xs__schema *schema)
-{ schemaRef = schema;
-}
-
-xs__schema* xs__element::schemaPtr() const
-{ return schemaRef;
-}
-
-void xs__element::elementPtr(xs__element *element)
-{ elementRef = element;
-}
-
-void xs__element::simpleTypePtr(xs__simpleType *simpleType)
-{ simpleTypeRef = simpleType;
-}
-
-void xs__element::complexTypePtr(xs__complexType *complexType)
-{ complexTypeRef = complexType;
-}
-
-xs__element *xs__element::elementPtr() const
-{ return elementRef;
-}
-
-const std::vector<xs__element*>* xs__element::substitutionsPtr() const
-{ return &substitutions;
-}
-
-xs__simpleType *xs__element::simpleTypePtr() const
-{ return simpleTypeRef;
-}
-
-xs__complexType *xs__element::complexTypePtr() const
-{ return complexTypeRef;
-}
-
-xs__simpleType::xs__simpleType()
-{ schemaRef = NULL;
-  level = 0;
-}
-
-int xs__simpleType::traverse(xs__schema &schema)
-{ if (vflag)
-    cerr << "   Analyzing schema simpleType '" << (name?name:"") << "'" << endl;
-  schemaRef = &schema;
-  if (list)
-    list->traverse(schema);
-  else if (restriction)
-    restriction->traverse(schema);
-  else if (union_)
-    union_->traverse(schema);
-  return SOAP_OK;
-}
-
-void xs__simpleType::schemaPtr(xs__schema *schema)
-{ schemaRef = schema;
-}
-
-xs__schema *xs__simpleType::schemaPtr() const
-{ return schemaRef;
-}
-
-int xs__simpleType::baseLevel()
-{ if (!level)
-  { if (restriction)
-    { level = -1;
-      if (restriction->simpleTypePtr())
-        level = restriction->simpleTypePtr()->baseLevel() + 1;
-      else
-        level = 2;
-    }
-    else if (list && list->restriction)
-    { level = -1;
-      if (list->restriction->simpleTypePtr())
-        level = list->restriction->simpleTypePtr()->baseLevel() + 1;
-      else
-        level = 2;
-    }
-    else
-      level = 1;
-  }
-  else if (level < 0)
-  { cerr << "Error: cyclic simpleType restriction/extension base dependency in '" << (name?name:"") << "'" << endl;
-  }
-  return level;
-}
-
-xs__complexType::xs__complexType()
-{ schemaRef = NULL;
-  level = 0;
-}
-
-int xs__complexType::traverse(xs__schema &schema)
-{ if (vflag)
-    cerr << "   Analyzing schema complexType '" << (name?name:"") << "'" << endl;
-  schemaRef = &schema;
-  if (simpleContent)
-    simpleContent->traverse(schema);
-  else if (complexContent)
-    complexContent->traverse(schema);
-  else if (all)
-    all->traverse(schema);
-  else if (choice)
-    choice->traverse(schema);
-  else if (sequence)
-    sequence->traverse(schema);
-  else if (any)
-    any->traverse(schema);
-  for (vector<xs__attribute>::iterator at = attribute.begin(); at != attribute.end(); ++at)
-    (*at).traverse(schema);
-  for (vector<xs__attributeGroup>::iterator ag = attributeGroup.begin(); ag != attributeGroup.end(); ++ag)
-    (*ag).traverse(schema);
-  return SOAP_OK;
-}
-
-void xs__complexType::schemaPtr(xs__schema *schema)
-{ schemaRef = schema;
-}
-
-xs__schema *xs__complexType::schemaPtr() const
-{ return schemaRef;
-}
-
-int xs__complexType::baseLevel()
-{ if (!level)
-  { if (simpleContent)
-    { if (simpleContent->restriction)
-      { level = -1;
-        if (simpleContent->restriction->simpleTypePtr())
-          level = simpleContent->restriction->simpleTypePtr()->baseLevel() + 1;
-        else if (simpleContent->restriction->complexTypePtr())
-          level = simpleContent->restriction->complexTypePtr()->baseLevel() + 1;
-        else
-          level = 2;
-      }
-      else if (simpleContent->extension)
-      { level = -1;
-        if (simpleContent->extension->simpleTypePtr())
-          level = simpleContent->extension->simpleTypePtr()->baseLevel() + 1;
-        else if (simpleContent->extension->complexTypePtr())
-          level = simpleContent->extension->complexTypePtr()->baseLevel() + 1;
-        else
-          level = 2;
-      }
-    }
-    else if (complexContent)
-    { if (complexContent->restriction)
-      { level = -1;
-        if (complexContent->restriction->simpleTypePtr())
-          level = complexContent->restriction->simpleTypePtr()->baseLevel() + 1;
-        else if (complexContent->restriction->complexTypePtr())
-          level = complexContent->restriction->complexTypePtr()->baseLevel() + 1;
-        else
-          level = 2;
-      }
-      else if (complexContent->extension)
-      { level = -1;
-        if (complexContent->extension->simpleTypePtr())
-          level = complexContent->extension->simpleTypePtr()->baseLevel() + 1;
-        else if (complexContent->extension->complexTypePtr())
-          level = complexContent->extension->complexTypePtr()->baseLevel() + 1;
-        else
-          level = 2;
-      }
-    }
-    else
-      level = 1;
-  }
-  else if (level < 0)
-  { cerr << "Error: cyclic complexType restriction/extension base dependency in '" << (name?name:"") << "'" << endl;
-  }
-  return level;
-}
-
-int xs__simpleContent::traverse(xs__schema &schema)
-{ if (vflag)
-    cerr << "   Analyzing schema simpleContent" << endl;
-  if (extension)
-    extension->traverse(schema);
-  else if (restriction)
-    restriction->traverse(schema);
-  return SOAP_OK;
-}
-
-int xs__complexContent::traverse(xs__schema &schema)
-{ if (vflag)
-    cerr << "   Analyzing schema complexContent" << endl;
-  if (extension)
-    extension->traverse(schema);
-  else if (restriction)
-    restriction->traverse(schema);
-  return SOAP_OK;
-}
-
-xs__extension::xs__extension()
-{ simpleTypeRef = NULL;
-  complexTypeRef = NULL;
-}
-
-int xs__extension::traverse(xs__schema &schema)
-{ if (vflag)
-    cerr << "   Analyzing schema extension '" << (base?base:"") << "'" << endl;
-  if (group)
-    group->traverse(schema);
-  else if (all)
-    all->traverse(schema);
-  else if (choice)
-    choice->traverse(schema);
-  else if (sequence)
-    sequence->traverse(schema);
-  for (vector<xs__attribute>::iterator at = attribute.begin(); at != attribute.end(); ++at)
-    (*at).traverse(schema);
-  for (vector<xs__attributeGroup>::iterator ag = attributeGroup.begin(); ag != attributeGroup.end(); ++ag)
-    (*ag).traverse(schema);
-  const char *token = qname_token(base, schema.targetNamespace);
-  simpleTypeRef = NULL;
-  if (token)
-  { for (vector<xs__simpleType>::iterator i = schema.simpleType.begin(); i != schema.simpleType.end(); ++i)
-      if (!strcmp((*i).name, token))
-      { simpleTypeRef = &(*i);
-        if (vflag)
-          cerr << "    Found extension base type '" << (token?token:"") << "'" << endl;
-        break;
-      }
-  }
-  if (!simpleTypeRef)
-  { for (vector<xs__import>::const_iterator i = schema.import.begin(); i != schema.import.end(); ++i)
-    { xs__schema *s = (*i).schemaPtr();
-      if (s)
-      { token = qname_token(base, s->targetNamespace);
-        if (token)
-        { for (vector<xs__simpleType>::iterator j = s->simpleType.begin(); j != s->simpleType.end(); ++j)
-          { if (!strcmp((*j).name, token))
-            { simpleTypeRef = &(*j);
-              if (vflag)
-                cerr << "    Found extension base type '" << (token?token:"") << "'" << endl;
-              break;
-            }
-	  }
-	  if (simpleTypeRef)
-            break;
-        }
-      }
-    }
-  }
-  token = qname_token(base, schema.targetNamespace);
-  complexTypeRef = NULL;
-  if (token)
-  { for (vector<xs__complexType>::iterator i = schema.complexType.begin(); i != schema.complexType.end(); ++i)
-      if ((*i).name && !strcmp((*i).name, token))
-      { complexTypeRef = &(*i);
-        if (vflag)
-          cerr << "    Found extension base type '" << (token?token:"") << "'" << endl;
-        break;
-      }
-  }
-  if (!complexTypeRef)
-  { for (vector<xs__import>::const_iterator i = schema.import.begin(); i != schema.import.end(); ++i)
-    { xs__schema *s = (*i).schemaPtr();
-      if (s)
-      { token = qname_token(base, s->targetNamespace);
-        if (token)
-        { for (vector<xs__complexType>::iterator j = s->complexType.begin(); j != s->complexType.end(); ++j)
-          { if ((*j).name && !strcmp((*j).name, token))
-            { complexTypeRef = &(*j);
-              if (vflag)
-                cerr << "    Found extension base type '" << (token?token:"") << "'" << endl;
-              break;
-            }
-	  }
-	  if (complexTypeRef)
-            break;
-        }
-      }
-    }
-  }
-  if (!simpleTypeRef && !complexTypeRef)
-  { if (base)
-    { if (is_builtin_qname(base))
-        schema.builtinType(base);
-      else if (!Wflag)
-	cerr << "Warning: could not find extension base type '" << base << "' in schema '" << (schema.targetNamespace?schema.targetNamespace:"") << "'" << endl;
-    }
-    else
-      cerr << "Extension has no base" << endl;
-  }
-  return SOAP_OK;
-}
-
-void xs__extension::simpleTypePtr(xs__simpleType *simpleType)
-{ simpleTypeRef = simpleType;
-}
-
-void xs__extension::complexTypePtr(xs__complexType *complexType)
-{ complexTypeRef = complexType;
-}
-
-xs__simpleType *xs__extension::simpleTypePtr() const
-{ return simpleTypeRef;
-}
-
-xs__complexType *xs__extension::complexTypePtr() const
-{ return complexTypeRef;
-}
-
-xs__restriction::xs__restriction()
-{ simpleTypeRef = NULL;
-  complexTypeRef = NULL;
-}
-
-int xs__restriction::traverse(xs__schema &schema)
-{ if (vflag)
-    cerr << "   Analyzing schema restriction '" << (base?base:"") << "'" << endl;
-  if (simpleType)
-    simpleType->traverse(schema);
-  if (attributeGroup)
-    attributeGroup->traverse(schema);
-  if (group)
-    group->traverse(schema);
-  else if (all)
-    all->traverse(schema);
-  else if (choice)
-    choice->traverse(schema);
-  else if (sequence)
-    sequence->traverse(schema);
-  else
-  { for (vector<xs__enumeration>::iterator en = enumeration.begin(); en != enumeration.end(); ++en)
-      (*en).traverse(schema);
-    for (vector<xs__pattern>::iterator pn = pattern.begin(); pn != pattern.end(); ++pn)
-      (*pn).traverse(schema);
-  }
-  for (vector<xs__attribute>::iterator at = attribute.begin(); at != attribute.end(); ++at)
-    (*at).traverse(schema);
-  const char *token = qname_token(base, schema.targetNamespace);
-  simpleTypeRef = NULL;
-  if (token)
-  { for (vector<xs__simpleType>::iterator i = schema.simpleType.begin(); i != schema.simpleType.end(); ++i)
-      if (!strcmp((*i).name, token))
-      { simpleTypeRef = &(*i);
-        if (vflag)
-          cerr << "    Found restriction base type '" << (token?token:"") << "'" << endl;
-        break;
-      }
-  }
-  if (!simpleTypeRef)
-  { for (vector<xs__import>::const_iterator i = schema.import.begin(); i != schema.import.end(); ++i)
-    { xs__schema *s = (*i).schemaPtr();
-      if (s)
-      { token = qname_token(base, s->targetNamespace);
-        if (token)
-        { for (vector<xs__simpleType>::iterator j = s->simpleType.begin(); j != s->simpleType.end(); ++j)
-          { if (!strcmp((*j).name, token))
-            { simpleTypeRef = &(*j);
-              if (vflag)
-                cerr << "    Found restriction base type '" << (token?token:"") << "'" << endl;
-              break;
-            }
-	  }
-	  if (simpleTypeRef)
-            break;
-        }
-      }
-    }
-  }
-  token = qname_token(base, schema.targetNamespace);
-  complexTypeRef = NULL;
-  if (token)
-  { for (vector<xs__complexType>::iterator i = schema.complexType.begin(); i != schema.complexType.end(); ++i)
-      if ((*i).name && !strcmp((*i).name, token))
-      { complexTypeRef = &(*i);
-        if (vflag)
-          cerr << "    Found restriction base type '" << (token?token:"") << "'" << endl;
-        break;
-      }
-  }
-  if (!complexTypeRef)
-  { for (vector<xs__import>::const_iterator i = schema.import.begin(); i != schema.import.end(); ++i)
-    { xs__schema *s = (*i).schemaPtr();
-      if (s)
-      { token = qname_token(base, s->targetNamespace);
-        if (token)
-        { for (vector<xs__complexType>::iterator j = s->complexType.begin(); j != s->complexType.end(); ++j)
-          { if ((*j).name && !strcmp((*j).name, token))
-            { complexTypeRef = &(*j);
-              if (vflag)
-                cerr << "    Found restriction base type '" << (token?token:"") << "'" << endl;
-              break;
-            }
-	  }
-	  if (complexTypeRef)
-            break;
-        }
-      }
-    }
-  }
-  if (!simpleTypeRef && !complexTypeRef)
-  { if (base)
-    { if (is_builtin_qname(base))
-        schema.builtinType(base);
-      else if (!Wflag)
-	cerr << "Warning: could not find restriction base type '" << base << "' in schema '" << (schema.targetNamespace?schema.targetNamespace:"") << "'" << endl;
-    }
-    else if (!simpleType)
-      cerr << "Restriction has no base" << endl;
-  }
-  return SOAP_OK;
-}
-
-void xs__restriction::simpleTypePtr(xs__simpleType *simpleType)
-{ simpleTypeRef = simpleType;
-}
-
-void xs__restriction::complexTypePtr(xs__complexType *complexType)
-{ complexTypeRef = complexType;
-}
-
-xs__simpleType *xs__restriction::simpleTypePtr() const
-{ return simpleTypeRef;
-}
-
-xs__complexType *xs__restriction::complexTypePtr() const
-{ return complexTypeRef;
-}
-
-xs__list::xs__list()
-{ itemTypeRef = NULL;
-}
-
-int xs__list::traverse(xs__schema &schema)
-{ if (vflag)
-    cerr << "   Analyzing schema list" << endl;
-  if (restriction)
-    restriction->traverse(schema);
-  for (vector<xs__simpleType>::iterator i = simpleType.begin(); i != simpleType.end(); ++i)
-    (*i).traverse(schema);
-  itemTypeRef = NULL;
-  const char *token = qname_token(itemType, schema.targetNamespace);
-  if (token)
-  { for (vector<xs__simpleType>::iterator i = schema.simpleType.begin(); i != schema.simpleType.end(); ++i)
-      if (!strcmp((*i).name, token))
-      { itemTypeRef = &(*i);
-        if (vflag)
-          cerr << "    Found list itemType '" << (token?token:"") << "'" << endl;
-        break;
-      }
-  }
-  if (!itemTypeRef)
-  { for (vector<xs__import>::const_iterator i = schema.import.begin(); i != schema.import.end(); ++i)
-    { xs__schema *s = (*i).schemaPtr();
-      if (s)
-      { token = qname_token(itemType, s->targetNamespace);
-        if (token)
-        { for (vector<xs__simpleType>::iterator j = s->simpleType.begin(); j != s->simpleType.end(); ++j)
-          { if (!strcmp((*j).name, token))
-            { itemTypeRef = &(*j);
-              if (vflag)
-                cerr << "    Found list itemType '" << (token?token:"") << "'" << endl;
-              break;
-            }
-	  }
-	  if (itemTypeRef)
-            break;
-        }
-      }
-    }
-  }
-  if (itemType && !itemTypeRef)
-  { if (is_builtin_qname(itemType))
-      schema.builtinType(itemType);
-    else if (!Wflag)
-      cerr << "Warning: could not find list itemType '" << itemType << "' in schema '" << (schema.targetNamespace?schema.targetNamespace:"") << "'" << endl;
-  }
-  return SOAP_OK;
-}
-
-void xs__list::itemTypePtr(xs__simpleType *simpleType)
-{ itemTypeRef = simpleType;
-}
-
-xs__simpleType *xs__list::itemTypePtr() const
-{ return itemTypeRef;
-}
-
-int xs__union::traverse(xs__schema &schema)
-{ if (vflag)
-    cerr << "   Analyzing schema union" << endl;
-  for (vector<xs__simpleType>::iterator i = simpleType.begin(); i != simpleType.end(); ++i)
-    (*i).traverse(schema);
-  return SOAP_OK;
-}
-
-int xs__all::traverse(xs__schema &schema)
-{ if (vflag)
-    cerr << "   Analyzing schema all" << endl;
-  for (vector<xs__element>::iterator i = element.begin(); i != element.end(); ++i)
-    (*i).traverse(schema);
-  return SOAP_OK;
-}
-
-int xs__contents::traverse(xs__schema &schema)
-{ switch (__union)
-  { case SOAP_UNION_xs__union_content_element:
-      if (__content.element)
-        __content.element->traverse(schema);
-      break;
-    case SOAP_UNION_xs__union_content_group:
-      if (__content.group)
-        __content.group->traverse(schema);
-      break;
-    case SOAP_UNION_xs__union_content_choice:
-      if (__content.choice)
-        __content.choice->traverse(schema);
-      break;
-    case SOAP_UNION_xs__union_content_sequence:
-      if (__content.sequence)
-        __content.sequence->traverse(schema);
-      break;
-    case SOAP_UNION_xs__union_content_any:
-      if (__content.any)
-        __content.any->traverse(schema);
-      break;
-  }
-  return SOAP_OK;
-}
-
-xs__seqchoice::xs__seqchoice()
-{ schemaRef = NULL;
-}
-
-int xs__seqchoice::traverse(xs__schema &schema)
-{ if (vflag)
-    cerr << "   Analyzing schema sequence/choice" << endl;
-  schemaRef = &schema;
-  for (vector<xs__contents>::iterator c = __contents.begin(); c != __contents.end(); ++c)
-    (*c).traverse(schema);
-  return SOAP_OK;
-}
-
-void xs__seqchoice::schemaPtr(xs__schema *schema)
-{ schemaRef = schema;
-}
-
-xs__schema *xs__seqchoice::schemaPtr() const
-{ return schemaRef;
-}
-
-xs__attributeGroup::xs__attributeGroup()
-{ schemaRef = NULL;
-  attributeGroupRef = NULL;
-}
-
-int xs__attributeGroup::traverse(xs__schema& schema)
-{ if (vflag)
-    cerr << "   Analyzing schema attributeGroup" << endl;
-  schemaRef = &schema;
-  for (vector<xs__attribute>::iterator at = attribute.begin(); at != attribute.end(); ++at)
-    (*at).traverse(schema);
-  for (vector<xs__attributeGroup>::iterator ag = attributeGroup.begin(); ag != attributeGroup.end(); ++ag)
-    (*ag).traverse(schema);
-  attributeGroupRef = NULL;
-  if (ref)
-  { const char *token = qname_token(ref, schema.targetNamespace);
-    if (token)
-    { for (vector<xs__attributeGroup>::iterator i = schema.attributeGroup.begin(); i != schema.attributeGroup.end(); ++i)
-        if (!strcmp((*i).name, token))
-        { attributeGroupRef = &(*i);
-          if (vflag)
-              cerr << "    Found attributeGroup '" << (name?name:"") << "' ref '" << (token?token:"") << "'" << endl;
-          break;
-        }
-    }
-    if (!attributeGroupRef)
-    { for (vector<xs__import>::const_iterator i = schema.import.begin(); i != schema.import.end(); ++i)
-      { xs__schema *s = (*i).schemaPtr();
-        if (s)
-        { token = qname_token(ref, s->targetNamespace);
-          if (token)
-          { for (vector<xs__attributeGroup>::iterator j = s->attributeGroup.begin(); j != s->attributeGroup.end(); ++j)
-            { if (!strcmp((*j).name, token))
-              { attributeGroupRef = &(*j);
-                if (vflag)
-                    cerr << "    Found attribute Group '" << (name?name:"") << "' ref '" << (token?token:"") << "'" << endl;
-                break;
-              }
-	    }
-	    if (attributeGroupRef)
-              break;
-          }
-        }
-      }
-    }
-    if (!attributeGroupRef)
-      if (!Wflag)
-        cerr << "Warning: could not find attributeGroup '" << (name?name:"") << "' ref '" << (ref?ref:"") << "' in schema '" << (schema.targetNamespace?schema.targetNamespace:"") << "'" << endl;
-  }
-  return SOAP_OK;
-}
-
-void xs__attributeGroup::schemaPtr(xs__schema *schema)
-{ schemaRef = schema;
-}
-
-void xs__attributeGroup::attributeGroupPtr(xs__attributeGroup *attributeGroup)
-{ attributeGroupRef = attributeGroup;
-}
-
-xs__schema *xs__attributeGroup::schemaPtr() const
-{ return schemaRef;
-}
-
-xs__attributeGroup *xs__attributeGroup::attributeGroupPtr() const
-{ return attributeGroupRef;
-}
-
-int xs__any::traverse(xs__schema &schema)
-{ if (vflag)
-    cerr << "   Analyzing schema any" << endl;
-  for (vector<xs__element>::iterator i = element.begin(); i != element.end(); ++i)
-    (*i).traverse(schema);
-  return SOAP_OK;
-}
-
-xs__group::xs__group()
-{ schemaRef = NULL;
-  groupRef = NULL;
-}
-
-int xs__group::traverse(xs__schema &schema)
-{ if (vflag)
-    cerr << "   Analyzing schema group" << endl;
-  schemaRef = &schema;
-  if (all)
-    all->traverse(schema);
-  else if (choice)
-    choice->traverse(schema);
-  else if (sequence)
-    sequence->traverse(schema);
-  groupRef = NULL;
-  if (ref)
-  { const char *token = qname_token(ref, schema.targetNamespace);
-    if (token)
-    { for (vector<xs__group>::iterator i = schema.group.begin(); i != schema.group.end(); ++i)
-        if (!strcmp((*i).name, token))
-        { groupRef = &(*i);
-          if (vflag)
-              cerr << "    Found group '" << (name?name:"") << "' ref '" << (token?token:"") << "'" << endl;
-          break;
-        }
-    }
-    if (!groupRef)
-    { for (vector<xs__import>::const_iterator i = schema.import.begin(); i != schema.import.end(); ++i)
-      { xs__schema *s = (*i).schemaPtr();
-        if (s)
-        { token = qname_token(ref, s->targetNamespace);
-          if (token)
-          { for (vector<xs__group>::iterator j = s->group.begin(); j != s->group.end(); ++j)
-            { if (!strcmp((*j).name, token))
-              { groupRef = &(*j);
-                if (vflag)
-                    cerr << "    Found group '" << (name?name:"") << "' ref '" << (token?token:"") << "'" << endl;
-                break;
-              }
-	    }
-	    if (groupRef)
-              break;
-          }
-        }
-      }
-    }
-    if (!groupRef)
-      if (!Wflag)
-        cerr << "Warning: could not find group '" << (name?name:"") << "' ref '" << (ref?ref:"") << "' in schema '" << (schema.targetNamespace?schema.targetNamespace:"") << "'" << endl;
-  }
-  return SOAP_OK;
-}
-
-void xs__group::schemaPtr(xs__schema *schema)
-{ schemaRef = schema;
-}
-
-xs__schema* xs__group::schemaPtr() const
-{ return schemaRef;
-}
-
-void xs__group::groupPtr(xs__group *group)
-{ groupRef = group;
-}
-
-xs__group* xs__group::groupPtr() const
-{ return groupRef;
-}
-
-int xs__enumeration::traverse(xs__schema &schema)
-{ if (vflag)
-    cerr << "   Analyzing schema enumeration '" << (value?value:"") << "'" << endl;
-  return SOAP_OK;
-}
-
-int xs__pattern::traverse(xs__schema &schema)
-{ if (vflag)
-    cerr << "   Analyzing schema pattern" << endl;
-  return SOAP_OK;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-//
-//	I/O
-//
-////////////////////////////////////////////////////////////////////////////////
-
-ostream &operator<<(ostream &o, const xs__schema &e)
-{ if (!e.soap)
-  { struct soap soap;
-    soap_init2(&soap, SOAP_IO_DEFAULT, SOAP_XML_TREE | SOAP_C_UTFSTRING);
-    soap_set_namespaces(&soap, namespaces);
-    e.soap_serialize(&soap);
-    soap_begin_send(&soap);
-    e.soap_out(&soap, "xs:schema", 0, NULL);
-    soap_end_send(&soap);
-    soap_end(&soap);
-    soap_done(&soap);
-  }
-  else
-  { ostream *os = e.soap->os;
-    e.soap->os = &o;
-    e.soap_serialize(e.soap);
-    soap_begin_send(e.soap);
-    e.soap_out(e.soap, "xs:schema", 0, NULL);
-    soap_end_send(e.soap);
-    e.soap->os = os;
-  }
-  return o;
-}
-
-istream &operator>>(istream &i, xs__schema &e)
-{ if (!e.soap)
-  { e.soap = soap_new();
-    soap_set_namespaces(e.soap, namespaces);
-  }
-  istream *is = e.soap->is;
-  e.soap->is = &i;
-  if (soap_begin_recv(e.soap)
-   || !e.soap_in(e.soap, "xs:schema", NULL)
-   || soap_end_recv(e.soap))
-  { // handle error? Note: e.soap->error is set and app should check
-  }
-  e.soap->is = is;
-  return i;
-}
-