diff GEMBASSY-1.0.3/gsoap/wsdl/schema.cpp @ 0:8300eb051bea draft

Initial upload

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/GEMBASSY-1.0.3/gsoap/wsdl/schema.cpp	Fri Jun 26 05:19:29 2015 -0400
@@ -0,0 +1,1699 @@
+/*
+	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;
+}
+