gembassy: GEMBASSY-1.0.3/gsoap/wsdl/types.cpp comparison

comparison GEMBASSY-1.0.3/gsoap/wsdl/types.cpp @ 0:8300eb051bea draft

Initial upload

author	ktnyt
date	Fri, 26 Jun 2015 05:19:29 -0400
parents
children

comparison

equal deleted inserted replaced

--1:000000000000
+:8300eb051bea
+/*
+	types.cpp
+	Generate gSOAP types from XML schemas (e.g. embedded in WSDL).
+--------------------------------------------------------------------------------
+gSOAP XML Web services tools
+Copyright (C) 2001-2013, 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:
+engelen@genivia.com / engelen@acm.org
+--------------------------------------------------------------------------------
+A commercial use license is available from Genivia, Inc., contact@genivia.com
+--------------------------------------------------------------------------------
+*/
+#include "types.h"
+static char *getline(char *s, size_t n, FILE *fd);
+static const char *nonblank(const char *s);
+static const char *fill(char *t, int n, const char *s, int e);
+static const char *utf8(char *t, const char *s);
+static const char *cstring(const char *s);
+static const char *xstring(const char *s);
+static bool is_integer(const char *s);
+static LONG64 to_integer(const char *s);
+static void documentation(const char *text);
+static void operations(const char *t);
+static int comment_nest = 0; /* keep track of block comments to avoid nesting */
+////////////////////////////////////////////////////////////////////////////////
+//
+//	Keywords and reserved words
+//
+////////////////////////////////////////////////////////////////////////////////
+static const char *keywords[] =
+{ "and",
+"asm",
+"auto",
+"bool",
+"break",
+"case",
+"catch",
+"char",
+"class",
+"const",
+"const_cast",
+"continue",
+"default",
+"delete",
+"do",
+"double",
+"dynamic_cast",
+"else",
+"enum",
+"errno",
+"explicit",
+"export",
+"extern",
+"false",
+"FILE",
+"float",
+"for",
+"friend",
+"goto",
+"if",
+"inline",
+"int",
+"interface",
+"long",
+"LONG64",
+"max",
+"min",
+"mustUnderstand",
+"mutable",
+"namespace",
+"new",
+"not",
+"NULL",
+"operator",
+"or",
+"private",
+"protected",
+"public",
+"_QName",
+"register",
+"reinterpret_cast",
+"restrict",
+"return",
+"short",
+"signed",
+"size_t",
+"sizeof",
+"soap",
+"static",
+"static_cast",
+"struct",
+"switch",
+"template",
+"this",
+"throw",
+"time_t",
+"true",
+"typedef",
+"typeid",
+"typeof",
+"typename",
+"ULONG64",
+"union",
+"unsigned",
+"using",
+"virtual",
+"void",
+"volatile",
+"wchar_t",
+"while",
+"XML",
+"_XML",
+"xor",
+};
+////////////////////////////////////////////////////////////////////////////////
+//
+//	Types methods
+//
+////////////////////////////////////////////////////////////////////////////////
+Types::Types()
+{ init();
+}
+int Types::read(const char *file)
+{ FILE *fd;
+char buf[1024], xsd[1024], def[1024], use[1024], ptr[1024], uri[1024];
+const char *s;
+short copy = 0;
+strcpy(buf, file);
+fd = fopen(buf, "r");
+if (!fd && import_path)
+{ strcpy(buf, import_path);
+strcat(buf, "/");
+strcat(buf, file);
+fd = fopen(buf, "r");
+}
+if (!fd)
+{ fprintf(stderr, "Cannot open file '%s'\n", buf);
+return SOAP_EOF;
+}
+fprintf(stderr, "Reading type definitions from type map file '%s'\n", buf);
+while (getline(buf, sizeof(buf), fd))
+{ s = buf;
+if (copy)
+{ if (*s == ']')
+copy = 0;
+else
+fprintf(stream, "%s\n", buf);
+}
+else if (*s == '[')
+copy = 1;
+else if (*s == '<')
+{ s = fill(uri, sizeof(uri), s+1, -1);
+infile[infiles++] = estrdup(uri);
+if (infiles >= MAXINFILES)
+{ fprintf(stderr, "wsdl2h: too many files\n");
+exit(1);
+}
+}
+else if (*s == '>')
+{ s = fill(uri, sizeof(uri), s+1, -1);
+if (!outfile)
+{ outfile = estrdup(uri);
+stream = fopen(outfile, "w");
+if (!stream)
+{ fprintf(stderr, "Cannot write to %s\n", outfile);
+exit(1);
+}
+if (cppnamespace)
+fprintf(stream, "namespace %s {\n", cppnamespace);
+fprintf(stderr, "Saving %s\n\n", outfile);
+}
+}
+else if (*s && *s != '#')
+{ s = fill(xsd, sizeof(xsd), s, '=');
+if (strstr(xsd, "__"))
+{ if (s && *s == '=')
+{ s = fill(use, sizeof(use), s+1, '|');
+if (*xsd && *use)
+{ s = estrdup(xsd);
+eqvtypemap[s] = estrdup(use);
+}
+}
+else
+{ s = fill(def, sizeof(def), s, '|');
+s = fill(use, sizeof(use), s, '|');
+s = fill(ptr, sizeof(ptr), s, '|');
+if (*xsd)
+{ s = estrdup(xsd);
+if (*def == '$')
+{ const char *t = modtypemap[s];
+if (t)
+{ char *r = (char*)emalloc(strlen(t) + strlen(def) + 1);
+strcpy(r, t);
+strcat(r, def);
+free((void*)modtypemap[s]);
+modtypemap[s] = r;
+}
+else
+modtypemap[s] = estrdup(def);
+}
+else
+{ if (*def)
+{ if (strcmp(def, "..."))
+deftypemap[s] = estrdup(def);
+}
+else
+deftypemap[s] = "";
+if (*use)
+usetypemap[s] = estrdupf(use);
+else
+usetypemap[s] = estrdupf(xsd);
+if (*ptr)
+ptrtypemap[s] = estrdupf(ptr);
+}
+}
+}
+}
+else if (*xsd)
+{ s = fill(uri, sizeof(uri), s, 0);
+if (uri[0] == '"')
+{ uri[strlen(uri) - 1] = '\0';
+nsprefix(xsd, estrdup(uri + 1));
+}
+else if (uri[0] == '<')
+{ uri[strlen(uri) - 1] = '\0';
+char *s = estrdup(uri + 1);
+nsprefix(xsd, s);
+exturis.insert(s);
+}
+else
+nsprefix(xsd, estrdup(uri));
+}
+}
+}
+fclose(fd);
+return SOAP_OK;
+}
+void Types::init()
+{ snum = 1;
+unum = 1;
+gnum = 1;
+with_union = false;
+fake_union = false;
+knames.insert(keywords, keywords + sizeof(keywords)/sizeof(char*));
+if (cflag)
+{ deftypemap["xsd__ur_type"] = "";
+if (dflag)
+{ usetypemap["xsd__ur_type"] = "xsd__anyType";
+ptrtypemap["xsd__ur_type"] = "xsd__anyType*";
+}
+else
+{ usetypemap["xsd__ur_type"] = "_XML";
+ptrtypemap["xsd__ur_type"] = "_XML";
+}
+}
+else
+{ deftypemap["xsd__ur_type"] = "class xsd__ur_type { _XML __item; struct soap *soap; };";
+usetypemap["xsd__ur_type"] = "xsd__ur_type";
+}
+if (cflag)
+{ deftypemap["xsd__anyType"] = "";
+if (dflag)
+{ usetypemap["xsd__anyType"] = "xsd__anyType";
+ptrtypemap["xsd__anyType"] = "xsd__anyType*";
+}
+else
+{ usetypemap["xsd__anyType"] = "_XML";
+ptrtypemap["xsd__anyType"] = "_XML";
+}
+}
+else
+{ if (dflag)
+{ deftypemap["xsd__anyType"] = "";
+usetypemap["xsd__anyType"] = "xsd__anyType";
+ptrtypemap["xsd__anyType"] = "xsd__anyType*";
+}
+else
+{ deftypemap["xsd__anyType"] = "class xsd__anyType { _XML __item; struct soap *soap; };";
+usetypemap["xsd__anyType"] = "xsd__anyType*";
+}
+}
+deftypemap["xsd__any"] = "";
+if (dflag)
+{ usetypemap["xsd__any"] = "xsd__anyType";
+ptrtypemap["xsd__any"] = "xsd__anyType*";
+}
+else
+{ usetypemap["xsd__any"] = "_XML";
+ptrtypemap["xsd__any"] = "_XML";
+}
+deftypemap["xsd__anyAttribute"] = "";
+if (dflag)
+{ usetypemap["xsd__anyAttribute"] = "xsd__anyAttribute";
+ptrtypemap["xsd__anyAttribute"] = "xsd__anyAttribute*";
+}
+else
+{ usetypemap["xsd__anyAttribute"] = "_XML";
+ptrtypemap["xsd__anyAttribute"] = "_XML";
+}
+if (cflag)
+{ deftypemap["xsd__base64Binary"] = "struct xsd__base64Binary\n{\tunsigned char *__ptr;\n\tint __size;\n\tchar *id, *type, *options; // NOTE: non-NULL for DIMEM/MIME/MTOM XOP attachments only\n};";
+usetypemap["xsd__base64Binary"] = "struct xsd__base64Binary";
+}
+else
+{ deftypemap["xsd__base64Binary"] = "class xsd__base64Binary\n{\tunsigned char *__ptr;\n\tint __size;\n\tchar *id, *type, *options; // NOTE: non-NULL for DIMEM/MIME/MTOM XOP attachments only\n\tstruct soap *soap;\n};";
+usetypemap["xsd__base64Binary"] = "xsd__base64Binary";
+}
+if (cflag)
+{ if (eflag)
+deftypemap["xsd__boolean"] = "enum xsd__boolean { false_, true_ };";
+else
+deftypemap["xsd__boolean"] = "enum xsd__boolean { xsd__boolean__false_, xsd__boolean__true_ };";
+usetypemap["xsd__boolean"] = "enum xsd__boolean";
+}
+else
+{ deftypemap["xsd__boolean"] = "";
+usetypemap["xsd__boolean"] = "bool";
+}
+deftypemap["xsd__byte"] = "typedef char xsd__byte;";
+usetypemap["xsd__byte"] = "xsd__byte";
+deftypemap["xsd__dateTime"] = "";
+usetypemap["xsd__dateTime"] = "time_t";
+deftypemap["xsd__double"] = "";
+usetypemap["xsd__double"] = "double";
+deftypemap["xsd__float"] = "";
+usetypemap["xsd__float"] = "float";
+if (cflag)
+{ deftypemap["xsd__hexBinary"] = "struct xsd__hexBinary { unsigned char *__ptr; int __size; };";
+usetypemap["xsd__hexBinary"] = "struct xsd__hexBinary";
+}
+else
+{ deftypemap["xsd__hexBinary"] = "class xsd__hexBinary { unsigned char *__ptr; int __size; };";
+usetypemap["xsd__hexBinary"] = "xsd__hexBinary";
+}
+deftypemap["xsd__int"] = "";
+usetypemap["xsd__int"] = "int";
+deftypemap["xsd__long"] = "";
+usetypemap["xsd__long"] = "LONG64";
+deftypemap["xsd__short"] = "";
+usetypemap["xsd__short"] = "short";
+if (cflag || sflag)
+{ deftypemap["xsd__string"] = "";
+usetypemap["xsd__string"] = "char*";
+}
+else
+{ deftypemap["xsd__string"] = "";
+usetypemap["xsd__string"] = "std::string";
+}
+if (cflag || sflag)
+{ deftypemap["xsd__QName"] = "";
+usetypemap["xsd__QName"] = "_QName";
+ptrtypemap["xsd__QName"] = "_QName";
+}
+else
+{ deftypemap["xsd__QName"] = "typedef std::string xsd__QName;";
+usetypemap["xsd__QName"] = "xsd__QName";
+}
+deftypemap["xsd__unsignedByte"] = "typedef unsigned char xsd__unsignedByte;";
+usetypemap["xsd__unsignedByte"] = "xsd__unsignedByte";
+deftypemap["xsd__unsignedInt"] = "";
+usetypemap["xsd__unsignedInt"] = "unsigned int";
+deftypemap["xsd__unsignedLong"] = "";
+usetypemap["xsd__unsignedLong"] = "ULONG64";
+deftypemap["xsd__unsignedShort"] = "";
+usetypemap["xsd__unsignedShort"] = "unsigned short";
+if (cflag)
+{ deftypemap["SOAP_ENC__base64Binary"] = "struct SOAP_ENC__base64Binary { unsigned char *__ptr; int __size; };";
+usetypemap["SOAP_ENC__base64Binary"] = "struct SOAP_ENC__base64Binary";
+deftypemap["SOAP_ENC__base64"] = "struct SOAP_ENC__base64 { unsigned char *__ptr; int __size; };";
+usetypemap["SOAP_ENC__base64"] = "struct SOAP_ENC__base64";
+}
+else
+{ deftypemap["SOAP_ENC__base64Binary"] = "class SOAP_ENC__base64Binary { unsigned char *__ptr; int __size; };";
+usetypemap["SOAP_ENC__base64Binary"] = "SOAP_ENC__base64Binary";
+deftypemap["SOAP_ENC__base64"] = "class SOAP_ENC__base64 { unsigned char *__ptr; int __size; };";
+usetypemap["SOAP_ENC__base64"] = "SOAP_ENC__base64";
+}
+if (cflag)
+{ deftypemap["SOAP_ENC__boolean"] = "enum SOAP_ENC__boolean { false_, true_ };";
+usetypemap["SOAP_ENC__boolean"] = "enum SOAP_ENC__boolean";
+}
+else
+{ deftypemap["SOAP_ENC__boolean"] = "typedef bool SOAP_ENC__boolean;";
+usetypemap["SOAP_ENC__boolean"] = "SOAP_ENC__boolean";
+}
+deftypemap["SOAP_ENC__byte"] = "typedef char SOAP_ENC__byte;";
+usetypemap["SOAP_ENC__byte"] = "SOAP_ENC__byte";
+deftypemap["SOAP_ENC__dateTime"] = "typedef time_t SOAP_ENC__dateTime;";
+usetypemap["SOAP_ENC__dateTime"] = "SOAP_ENC__dateTime";
+deftypemap["SOAP_ENC__double"] = "typedef double SOAP_ENC__double;";
+usetypemap["SOAP_ENC__double"] = "SOAP_ENC__double";
+deftypemap["SOAP_ENC__float"] = "typedef float SOAP_ENC__float";
+usetypemap["SOAP_ENC__float"] = "SOAP_ENC__float";
+if (cflag)
+{ deftypemap["SOAP_ENC__hexBinary"] = "struct SOAP_ENC__hexBinary { unsigned char *__ptr; int __size; };";
+usetypemap["SOAP_ENC__hexBinary"] = "struct SOAP_ENC__hexBinary";
+}
+else
+{ deftypemap["SOAP_ENC__hexBinary"] = "class SOAP_ENC__hexBinary { unsigned char *__ptr; int __size; };";
+usetypemap["SOAP_ENC__hexBinary"] = "SOAP_ENC__hexBinary";
+}
+deftypemap["SOAP_ENC__int"] = "typedef int SOAP_ENC__int;";
+usetypemap["SOAP_ENC__int"] = "SOAP_ENC__int";
+deftypemap["SOAP_ENC__long"] = "typedef LONG64 SOAP_ENC__long;";
+usetypemap["SOAP_ENC__long"] = "SOAP_ENC__long";
+deftypemap["SOAP_ENC__short"] = "typedef short SOAP_ENC__short;";
+usetypemap["SOAP_ENC__short"] = "SOAP_ENC__short";
+if (cflag || sflag)
+{ deftypemap["SOAP_ENC__string"] = "";
+usetypemap["SOAP_ENC__string"] = "char*";
+}
+else
+{ deftypemap["SOAP_ENC__string"] = "";
+usetypemap["SOAP_ENC__string"] = "std::string";
+}
+deftypemap["SOAP_ENC__unsignedByte"] = "typedef unsigned char SOAP_ENC__unsignedByte;";
+usetypemap["SOAP_ENC__unsignedByte"] = "SOAP_ENC__unsignedByte";
+deftypemap["SOAP_ENC__unsignedInt"] = "typedef unsigned int SOAP_ENC__unsignedInt;";
+usetypemap["SOAP_ENC__unsignedInt"] = "SOAP_ENC__unsignedInt";
+deftypemap["SOAP_ENC__unsignedLong"] = "typedef ULONG64 SOAP_ENC__unsignedLong;";
+usetypemap["SOAP_ENC__unsignedLong"] = "SOAP_ENC__unsignedLong";
+deftypemap["SOAP_ENC__unsignedShort"] = "typedef unsigned short SOAP_ENC__unsignedShort;";
+usetypemap["SOAP_ENC__unsignedShort"] = "SOAP_ENC__unsignedShort";
+deftypemap["SOAP_ENC__Array"] = "";
+usetypemap["SOAP_ENC__Array"] = "struct { _XML *__ptr; int __size; }";
+deftypemap["_SOAP_ENC__arrayType"] = "";
+deftypemap["SOAP_ENV__Header"] = "";
+usetypemap["SOAP_ENV__Header"] = "struct SOAP_ENV__Header";
+deftypemap["_SOAP_ENV__mustUnderstand"] = "";
+if (cflag || sflag)
+usetypemap["_SOAP_ENV__mustUnderstand"] = "char*";
+else
+usetypemap["_SOAP_ENV__mustUnderstand"] = "std::string";
+deftypemap["SOAP_ENV__Fault"] = "";
+usetypemap["SOAP_ENV__Fault"] = "struct SOAP_ENV__Fault";
+deftypemap["SOAP_ENV__detail"] = "";
+usetypemap["SOAP_ENV__detail"] = "struct SOAP_ENV__Detail";
+deftypemap["SOAP_ENV__Detail"] = "";
+usetypemap["SOAP_ENV__Detail"] = "struct SOAP_ENV__Detail";
+deftypemap["SOAP_ENV__Code"] = "";
+usetypemap["SOAP_ENV__Code"] = "struct SOAP_ENV__Code";
+deftypemap["SOAP_ENV__Reason"] = "";
+usetypemap["SOAP_ENV__Reason"] = "struct SOAP_ENV__Reason";
+if (read(mapfile))
+fprintf(stderr, "Problem reading type map file '%s'.\nUsing internal type definitions for %s instead.\n\n", mapfile, cflag?"C":"C++");
+}
+const char *Types::nsprefix(const char *prefix, const char *URI)
+{ if (URI)
+{ const char *s = uris[URI];
+if (!s)
+{ size_t n;
+if (!prefix || !*prefix || *prefix == '_')
+s = schema_prefix;
+else
+s = estrdup(prefix);
+if (!syms[s])
+n = syms[s] = 1;
+else
+n = ++syms[s];
+if (n != 1 || !prefix || !*prefix || *prefix == '_')
+{ char *t = (char*)emalloc(strlen(s) + 16);
+sprintf(t, "%s%lu", s, (unsigned long)n);
+s = t;
+}
+uris[URI] = s;
+if (vflag)
+fprintf(stderr, "namespace prefix %s = \"%s\"\n", s, URI);
+}
+// if *prefix == '_', then add prefix string to s
+if (prefix && *prefix == '_')
+{ char *t = (char*)emalloc(strlen(s) + 2);
+*t = '_';
+strcpy(t + 1, s);
+s = t;
+}
+return s;
+}
+return NULL;
+}
+const char *Types::prefix(const char *name)
+{ const char *s;
+char *t;
+if (*name == '"')
+{ s = strchr(name + 1, '"');
+t = (char*)emalloc(s - name);
+strncpy(t, name + 1, s - name - 1);
+t[s - name - 1] = '\0';
+return nsprefix(NULL, t);
+}
+s = strchr(name, ':');
+if (s)
+{ t = (char*)emalloc(s - name + 1);
+strncpy(t, name, s - name);
+t[s - name] = '\0';
+return t;
+}
+return NULL;
+}
+const char *Types::uri(const char *name)
+{ const char *s;
+char *t;
+if (*name == '"')
+{ s = strchr(name + 1, '"');
+t = (char*)emalloc(s - name);
+strncpy(t, name + 1, s - name - 1);
+t[s - name - 1] = '\0';
+return t;
+}
+s = strchr(name, ':');
+if (s)
+{ struct Namespace *p = namespaces;
+if (p)
+{ for (p += 6; p->id; p++)
+{ if (!strncmp(p->id, name, s - name) && !p->id[s - name])
+{ if (p->in && *p->in)
+return p->in;
+return p->ns;
+}
+}
+}
+}
+return NULL;
+}
+// Find a C name for a QName. If the name has no qualifier, use URI. Suggest prefix for URI
+const char *Types::fname(const char *prefix, const char *URI, const char *qname, SetOfString *reserved, enum Lookup lookup, bool isqname)
+{ char buf[1024], *t;
+const char *p, *s, *name;
+if (!qname)
+{ fprintf(stream, "// Warning: internal error, no QName in fname()\n");
+if (vflag)
+fprintf(stderr, "Internal error, no QName in fname()\n");
+qname = "?";
+}
+name = qname;
+if (isqname)
+s = strrchr(name, ':');
+else
+s = NULL;
+if (s)
+{ name = s + 1;
+if (qname[0] == '"' && qname[1] == '"')
+s = NULL;
+else if (*qname == '"')
+{ t = (char*)emalloc(s - qname - 1);
+strncpy(t, qname + 1, s - qname - 2);
+t[s - qname - 2] = '\0';
+URI = t;
+}
+else if (!strncmp(qname, "xs:", 3))	// this hack is necessary since the nsmap table defines "xs" for "xsd"
+{ s = "xsd";
+URI = NULL;
+}
+else
+{ t = (char*)emalloc(s - qname + 1);
+strncpy(t, qname, s - qname);
+t[s - qname] = '\0';
+s = t;
+URI = NULL;
+}
+}
+if (URI)
+p = nsprefix(prefix, URI);
+else if (s)
+p = s;
+else
+p = "";
+s = NULL;
+if (lookup == LOOKUP)
+{ if (qnames.find(Pair(p,name)) != qnames.end())
+s = qnames[Pair(p,name)];
+}
+if (!s)
+{ t = buf;
+if (!prefix || *prefix)
+{ s = p;
+// no longer add '_' when URI != NULL, since nsprefix() will do this
+if (prefix && *prefix == ':')
+*t++ = ':';
+else if (prefix && *prefix == '_')
+{ if (!URI)
+*t++ = '_';
+if (prefix[1] == '_') // ensures ns prefix starts with __
+{ strcpy(t, prefix + 1);
+t += strlen(prefix + 1);
+}
+}
+if (s && *s)
+{ for (; *s; s++)
+{ if (isalnum(*s))
+*t++ = *s;
+else if (*s == '-' && s[1] != '-' && s != p)
+*t++ = '_';
+else if (*s == '_')
+{ if (s == p)
+*t++ = '_';
+else if (!_flag)
+{ strcpy(t, "_USCORE");
+t += 7;
+}
+else
+{ s = utf8(t, s);
+t += 6;
+}
+}
+else
+{ s = utf8(t, s);
+t += 6;
+}
+}
+if (!prefix || *prefix != '*')
+{ *t++ = '_';
+*t++ = '_';
+}
+}
+else if (isdigit(*name))
+*t++ = '_';
+}
+for (s = name; *s; s++)
+{ if (isalnum(*s))
+*t++ = *s;
+else if (*s == '-' && s[1] != '-' && s[1] != '\0' && s != name)
+*t++ = '_';
+else if (!_flag && *s == '_')
+{ strcpy(t, "_USCORE");
+t += 7;
+}
+else
+{ s = utf8(t, s);
+t += 6;
+}
+if (t >= buf + sizeof(buf))
+break;
+}
+*t = '\0';
+while (knames.find(buf) != knames.end() || (reserved && reserved->find(buf) != reserved->end()))
+{ *t++ = '_';
+*t = '\0';
+}
+if (isalpha(*buf) || *buf == '_' || *buf == ':')
+{ t = (char*)emalloc(strlen(buf) + 1);
+strcpy(t, buf);
+}
+else
+{ t = (char*)emalloc(strlen(buf) + 2);
+*t = '_';
+strcpy(t + 1, buf);
+}
+if (lookup == LOOKUP)
+{ qnames[Pair(p,name)] = t;
+if (vflag)
+{ cerr << "Mapping '" << p << ":" << name << "' to '" << t << "'" << endl;
+#ifdef DEBUG
+for (MapOfPairToString::const_iterator i = qnames.begin(); i != qnames.end(); ++i)
+cerr << "Map[" << (*i).first.first << ":" << (*i).first.second << "]='" << (*i).second << "'" << endl;
+#endif
+}
+}
+s = t;
+}
+if (eqvtypemap.find(s) != eqvtypemap.end())
+s = eqvtypemap[s];
+return s;
+}
+bool Types::is_defined(const char *prefix, const char *URI, const char *qname)
+{ const char *t = fname(prefix, URI, qname, NULL, LOOKUP, true);
+return usetypemap.find(t) != usetypemap.end();
+}
+const char *Types::aname(const char *prefix, const char *URI, const char *qname)
+{ return fname(prefix, URI, qname, NULL, NOLOOKUP, true);
+}
+const char *Types::cname(const char *prefix, const char *URI, const char *qname)
+{ return fname(prefix, URI, qname, NULL, LOOKUP, true);
+}
+const char *Types::tname(const char *prefix, const char *URI, const char *qname)
+{ const char *s, *t;
+t = cname(prefix, URI, qname);
+if (usetypemap.find(t) != usetypemap.end())
+{ s = usetypemap[t];
+if (vflag)
+cerr << "Mapping use of '" << t << "' to '" << s << "'" << endl;
+}
+else
+{ s = t;
+fprintf(stream, "\n// Warning: undefined QName '%s' for type '%s' in namespace '%s' (FIXME: check WSDL and schema definitions)\n", qname?qname:"", t, URI?URI:"?");
+if (vflag)
+fprintf(stderr, "\nWarning: undefined QName '%s' for type '%s' in namespace '%s'\n", qname?qname:"", t, URI?URI:"?");
+}
+return s;
+}
+const char *Types::tnameptr(bool flag, const char *prefix, const char *URI, const char *qname)
+{ const char *s = pname(flag, prefix, URI, qname);
+if (flag)
+{ if (!strncmp(s, "char*", 5))
+return "char**";
+if (!strchr(s, '*'))
+{ char *r = (char*)emalloc(strlen(s) + 2);
+strcpy(r, s);
+strcat(r, "*");
+return r;
+}
+}
+return s;
+}
+const char *Types::pname(bool flag, const char *prefix, const char *URI, const char *qname)
+{ const char *r, *s = NULL, *t;
+t = cname(prefix, URI, qname);
+if (flag)
+{ if (ptrtypemap.find(t) != ptrtypemap.end())
+s = ptrtypemap[t];
+else
+{ if (usetypemap.find(t) != usetypemap.end())
+s = usetypemap[t];
+if (!s)
+{ s = t;
+fprintf(stream, "\n// Warning: undefined QName '%s' for pointer to type '%s' (FIXME: check WSDL and schema definitions)\n", qname, t);
+if (vflag)
+fprintf(stderr, "\nWarning: undefined QName '%s' for pointer to type '%s' in namespace '%s'\n", qname, t, URI?URI:"?");
+}
+r = s;
+while (r && *r)
+{ r = strchr(r + 1, '*');
+if (r && *(r-1) != '/' && *(r+1) != '/')
+break;
+}
+if (!r)	// already pointer?
+{ char *p = (char*)emalloc(strlen(s) + 2);
+strcpy(p, s);
+strcat(p, "*");
+s = p;
+}
+if (vflag)
+cerr << "Mapping pointer to '" << t << "' to '" << s << "'" << endl;
+ptrtypemap[t] = s;
+}
+}
+else if (usetypemap.find(t) != usetypemap.end())
+s = usetypemap[t];
+else
+{ s = t;
+fprintf(stream, "\n// Warning: undefined QName '%s' for type '%s' in namespace '%s' (FIXME: check WSDL and schema definitions)\n", qname, t, URI?URI:"?");
+if (vflag)
+fprintf(stderr, "\nWarning: undefined QName '%s' for type '%s' in namespace '%s'\n", qname, t, URI?URI:"?");
+}
+return s;
+}
+const char *Types::deftname(enum Type type, const char *pointer, bool is_pointer, const char *prefix, const char *URI, const char *qname)
+{ char buf[1024];
+char *s;
+const char *q = NULL, *t;
+t = fname(prefix, URI, qname, NULL, LOOKUP, true);
+if (deftypemap[t])
+{ if (vflag)
+fprintf(stderr, "Name %s already defined (probably in %s file)\n", qname, mapfile);
+return NULL;
+}
+if (usetypemap[t])
+{ if (vflag)
+fprintf(stderr, "Name %s is mapped\n", qname);
+return t;
+}
+switch (type)
+{ case ENUM:
+q = "enum";
+if (yflag)
+knames.insert(t);
+break;
+case STRUCT:
+q = "struct";
+if (yflag)
+knames.insert(t);
+break;
+case CLASS:
+case TYPEDEF:
+knames.insert(t);
+default:
+break;
+}
+if (q)
+{ strcpy(buf, q);
+strcat(buf, " ");
+}
+else
+buf[0] = '\0';
+strcat(buf, t);
+if (pointer)
+strcat(buf, pointer);
+s = (char*)emalloc(strlen(buf) + 1);
+strcpy(s, buf);
+usetypemap[t] = s;
+if (pointer || is_pointer)
+ptrtypemap[t] = s;
+if (vflag)
+cerr <<  "Defined '" << t << "' ('" << qname << "' in namespace '" << (URI?URI:prefix?prefix:"") << "') as '" << s << endl;
+return t;
+}
+// get enumeration value. URI/type refers to the enum simpleType.
+const char *Types::ename(const char *type, const char *value, bool isqname)
+{ const char *s = enames[Pair(type,value)];
+if (!s)
+{ s = fname(NULL, NULL, value, &rnames, NOLOOKUP, isqname);
+if (!eflag && type && *type)
+{ // Add prefix to enum
+if (!*s || (s[0] == '_' && s[1] == '\0'))
+s = "_x0000";
+char *buf = (char*)emalloc(strlen(type) + strlen(s) + 3);
+// _xXXXX is OK here
+if (s[0] == '_' && s[1] != 'x' && strncmp(s, "_USCORE", 7))
+sprintf(buf, "%s_%s", type, s);
+else
+sprintf(buf, "%s__%s", type, s);
+s = buf;
+}
+else
+rnames.insert(s);
+enames[Pair(type,value)] = s;
+}
+return s;
+}
+// get operation name
+const char *Types::oname(const char *prefix, const char *URI, const char *qname)
+{ const char *s = fname(prefix, URI, qname, NULL, LOOKUP, true);
+if (s && usetypemap.find(s) != usetypemap.end())
+{ // Avoid name clash with structs/classes of the same name
+onames.insert(s);
+}
+s = fname(prefix, URI, qname, &onames, NOLOOKUP, true);
+onames.insert(s);
+return s;
+}
+// generate struct name
+const char *Types::sname(const char *URI, const char *name)
+{ const char *s;
+char *t;
+if (!aflag && name)
+{ size_t len = 0;
+for (VectorOfString::const_iterator i = scope.begin(); i != scope.end(); ++i)
+len += strlen(*i) + 1;
+t = (char*)emalloc(len + strlen(name) + 1);
+*t = '\0';
+for (VectorOfString::const_iterator j = scope.begin(); j != scope.end(); ++j)
+{ strcat(t, *j);
+strcat(t, "-");
+}
+strcat(t, name);
+s = fname("_", URI, t, &rnames, NOLOOKUP, true);
+rnames.insert(s);
+}
+else if (URI)
+{ s = nsprefix(NULL, URI);
+t = (char*)emalloc(strlen(s) + 16);
+sprintf(t, "_%s__struct_%d", s, snum++);
+s = t;
+}
+else
+{ t = (char*)emalloc(16);
+sprintf(t, "struct_%d", snum++);
+s = t;
+}
+return s;
+}
+// generate union name
+const char *Types::uname(const char *URI)
+{ const char *s;
+char *t;
+if (!aflag)
+{ size_t len = 0;
+for (VectorOfString::const_iterator i = scope.begin(); i != scope.end(); ++i)
+len += strlen(*i) + 1;
+t = (char*)emalloc(len + 6);
+strcpy(t, "union");
+for (VectorOfString::const_iterator j = scope.begin(); j != scope.end(); ++j)
+{ strcat(t, "-");
+strcat(t, *j);
+}
+s = fname("_", URI, t, &rnames, NOLOOKUP, true);
+rnames.insert(s);
+}
+else if (URI)
+{ s = nsprefix(NULL, URI);
+t = (char*)emalloc(strlen(s) + 16);
+sprintf(t, "_%s__union_%d", s, unum++);
+s = t;
+}
+else
+{ t = (char*)emalloc(16);
+sprintf(t, "_union_%d", unum++);
+s = t;
+}
+return s;
+}
+// generate enum name
+const char *Types::gname(const char *URI, const char *name)
+{ const char *s;
+char *t;
+if (!aflag && name)
+{ size_t len = 0;
+for (VectorOfString::const_iterator i = scope.begin(); i != scope.end(); ++i)
+len += strlen(*i) + 1;
+t = (char*)emalloc(len + strlen(name) + 1);
+*t = '\0';
+for (VectorOfString::const_iterator j = scope.begin(); j != scope.end(); ++j)
+{ strcat(t, *j);
+strcat(t, "-");
+}
+strcat(t, name);
+s = fname("_", URI, t, &rnames, LOOKUP, true);
+rnames.insert(s);
+}
+else if (URI)
+{ s = nsprefix(NULL, URI);
+t = (char*)emalloc(strlen(s) + 16);
+sprintf(t, "_%s__enum_%d", s, gnum++);
+s = t;
+}
+else
+{ t = (char*)emalloc(16);
+sprintf(t, "enum_%d", gnum++);
+s = t;
+}
+return s;
+}
+// checks if nillable or minOccurs=0 (and no default value is present)
+bool Types::is_nillable(const xs__element& element)
+{ return !element.default_ && (element.nillable || (element.minOccurs && !strcmp(element.minOccurs, "0")));
+}
+bool Types::is_basetypeforunion(const char *prefix, const char *URI, const char *type)
+{ const char *t = tname(prefix, URI, type);
+if (!strcmp(t, "std::string") || !strcmp(t, "std::wstring"))
+return false;
+return is_basetype(prefix, URI, type);
+}
+bool Types::is_basetype(const char *prefix, const char *URI, const char *type)
+{ const char *t = tname(prefix, URI, type);
+if (!strncmp(t, "enum ", 5))
+return true;
+if (strstr(t, "__") && strcmp(t, "xsd__byte"))
+return false;
+return !strncmp(type, "xs:", 3) || !strncmp(type, "SOAP-ENC:", 9);
+}
+void Types::dump(FILE *fd)
+{ fprintf(fd, "\nTypes:\n");
+for (MapOfStringToString::const_iterator i = usetypemap.begin(); i != usetypemap.end(); ++i)
+fprintf(fd, "%s=%s\n", (*i).first, (*i).second?(*i).second:"(null)");
+fprintf(fd, "\nPointers:\n");
+for (MapOfStringToString::const_iterator j = ptrtypemap.begin(); j != ptrtypemap.end(); ++j)
+fprintf(fd, "%s=%s\n", (*j).first, (*j).second?(*j).second:"(null)");
+}
+void Types::define(const char *URI, const char *name, const xs__complexType& complexType)
+{ // generate prototype for structs/classes and store name
+const char *prefix = NULL;
+if (complexType.name)
+name = complexType.name;
+else
+prefix = "_";
+if (complexType.complexContent
+&& complexType.complexContent->restriction
+&& !strcmp(complexType.complexContent->restriction->base, "SOAP-ENC:Array"))
+{ if (strcmp(schema_prefix, "ns"))
+prefix = "*";
+else
+prefix = "";
+}
+if (cflag)
+{ const char *t = deftname(STRUCT, "*", true, prefix, URI, name);
+if (t)
+{ if (yflag)
+fprintf(stream, "\n/// Typedef synonym for struct %s.\ntypedef struct %s %s;\n", t, t, t);
+}
+else if (name)
+{ t = deftypemap[cname(prefix, URI, name)];
+if (t)
+{ fprintf(stream, "\n/// Imported complexType \"%s\":%s from typemap %s.\n", URI, name, mapfile?mapfile:"");
+document(complexType.annotation);
+if (*t)
+format(t);
+else
+fprintf(stream, "// complexType definition intentionally left blank.\n");
+}
+}
+}
+else
+{ const char *t = deftname(CLASS, "*", true, prefix, URI, name);
+if (t)
+fprintf(stream, "\n//  Forward declaration of class %s.\nclass %s;\n", t, t);
+else if (name)
+{ t = deftypemap[cname(prefix, URI, name)];
+if (t)
+{ fprintf(stream, "\n/// Imported complexType \"%s\":%s from typemap %s.\n", URI, name, mapfile?mapfile:"");
+document(complexType.annotation);
+if (*t)
+format(t);
+else
+fprintf(stream, "// complexType definition intentionally left blank.\n");
+}
+}
+}
+}
+void Types::gen(const char *URI, const char *name, const xs__simpleType& simpleType, bool anonymous)
+{ const char *t = NULL;
+const char *prefix = NULL;
+if (simpleType.name)
+name = simpleType.name;
+else
+prefix = "_";
+if (!anonymous)
+{ t = deftypemap[cname(NULL, URI, name)];
+if (t)
+{ fprintf(stream, "\n/// Imported simpleType \"%s\":%s from typemap %s.\n", URI, name, mapfile?mapfile:"");
+document(simpleType.annotation);
+if (*t)
+format(t);
+else
+fprintf(stream, "// simpleType definition intentionally left blank.\n");
+return;
+}
+}
+if (simpleType.restriction)
+{ const char *base = simpleType.restriction->base;
+if (!base && simpleType.restriction->simpleType)
+{ if (!anonymous)
+{ if (simpleType.restriction->simpleType->list && simpleType.restriction->length && simpleType.restriction->length->value)
+{ fprintf(stream, "\n/// \"%s\":%s is a simpleType restriction list with length %s.", URI?URI:"", name, simpleType.restriction->length->value);
+document(simpleType.restriction->length->annotation);
+}
+else
+fprintf(stream, "\n/// \"%s\":%s is a simpleType restriction.", URI?URI:"", name);
+}
+gen(URI, name, *simpleType.restriction->simpleType, anonymous);
+}
+else
+{ if (!base)
+base = "xsd:string";
+const char *baseURI = NULL;
+if (simpleType.restriction->simpleTypePtr() && simpleType.restriction->simpleTypePtr()->schemaPtr())
+baseURI = simpleType.restriction->simpleTypePtr()->schemaPtr()->targetNamespace;
+if (!anonymous)
+fprintf(stream, "\n/// \"%s\":%s is a simpleType restriction of %s.\n", URI?URI:"", name, base);
+document(simpleType.annotation);
+document(simpleType.restriction->annotation);
+if (!simpleType.restriction->enumeration.empty())
+{ bool is_numeric = true; // check if all enumeration values are numeric
+bool is_qname = !strcmp(base, "xs:QName");
+if (!anonymous)
+{ t = deftname(ENUM, NULL, false, prefix, URI, name);
+if (t && !eflag)
+fprintf(stream, "/// Note: enum values are prefixed with '%s' to avoid name clashes, please use wsdl2h option -e to omit this prefix\n", t);
+}
+if (!t)
+t = gname(URI, name);
+if (!anonymous)
+fprintf(stream, "enum %s\n{\n", t);
+else
+fprintf(stream, "    enum %s\n    {\n", t);
+for (vector<xs__enumeration>::const_iterator enumeration1 = simpleType.restriction->enumeration.begin(); enumeration1 != simpleType.restriction->enumeration.end(); ++enumeration1)
+{ const char *s;
+if ((s = (*enumeration1).value))
+is_numeric &= is_integer(s);
+}
+SetOfString enumvals;
+for (vector<xs__enumeration>::const_iterator enumeration2 = simpleType.restriction->enumeration.begin(); enumeration2 != simpleType.restriction->enumeration.end(); ++enumeration2)
+{ const char *s;
+document((*enumeration2).annotation);
+if ((s = (*enumeration2).value))
+{ if (!enumvals.count(s))
+{ enumvals.insert(s);
+if (is_numeric)
+fprintf(stream, "\t%s = %s,\t///< %s value=\"%s\"\n", ename(t, s, false), s, base, s);
+else if (is_qname && (*enumeration2).value_)
+fprintf(stream, "\t%s,\t///< %s value=\"%s\"\n", ename(t, (*enumeration2).value_, true), base, (*enumeration2).value_);
+else
+fprintf(stream, "\t%s,\t///< %s value=\"%s\"\n", ename(t, s, false), base, s);
+}
+}
+else
+fprintf(stream, "//\tunrecognized: enumeration '%s' has no value\n", name?name:"");
+}
+if (!anonymous)
+{ fprintf(stream, "};\n");
+if (yflag)
+fprintf(stream, "/// Typedef synonym for enum %s.\ntypedef enum %s %s;\n", t, t, t);
+if (pflag && simpleType.name)
+{ const char *s = aname(prefix, URI, name);
+knames.insert(s);
+s = aname(prefix, URI, name);
+fprintf(stream, "\n/// Class wrapper\n");
+fprintf(stream, "class %s : public xsd__anyType\n{ public:\n", s);
+fprintf(stream, elementformat, tname(prefix, URI, name), "__item;");
+modify(s);
+fprintf(stream, "\n};\n");
+}
+}
+else
+fprintf(stream, "    }\n");
+}
+else
+{ if (simpleType.restriction->length && simpleType.restriction->length->value)
+{ fprintf(stream, "/// Length of this string is exactly %s characters\n", simpleType.restriction->length->value);
+document(simpleType.restriction->length->annotation);
+}
+else
+{ const char *a = NULL, *b = NULL;
+if (simpleType.restriction->minLength)
+{ a = simpleType.restriction->minLength->value;
+document(simpleType.restriction->minLength->annotation);
+}
+if (simpleType.restriction->maxLength)
+{ b = simpleType.restriction->maxLength->value;
+document(simpleType.restriction->maxLength->annotation);
+}
+if (a || b)
+fprintf(stream, "/// Length of this string is within %s..%s characters\n", a?a:"0", b?b:"");
+}
+if (simpleType.restriction->precision && simpleType.restriction->precision->value)
+fprintf(stream, "/// %sprecision is %s (note: not automatically enforced)\n", simpleType.restriction->precision->fixed?"fixed ":"", simpleType.restriction->precision->value);
+if (simpleType.restriction->scale && simpleType.restriction->scale->value)
+fprintf(stream, "/// %sscale is %s (note: not automatically enforced)\n", simpleType.restriction->scale->fixed?"fixed ":"", simpleType.restriction->scale->value);
+if (simpleType.restriction->totalDigits && simpleType.restriction->totalDigits->value)
+fprintf(stream, "/// %snumber of total digits is %s (note: not automatically enforced)\n", simpleType.restriction->totalDigits->fixed?"fixed ":"", simpleType.restriction->totalDigits->value);
+if (simpleType.restriction->fractionDigits && simpleType.restriction->fractionDigits->value)
+fprintf(stream, "/// %snumber of fraction digits is %s (note: not automatically enforced)\n", simpleType.restriction->fractionDigits->fixed?"fixed ":"", simpleType.restriction->fractionDigits->value);
+for (vector<xs__pattern>::const_iterator pattern1 = simpleType.restriction->pattern.begin(); pattern1 != simpleType.restriction->pattern.end(); ++pattern1)
+fprintf(stream, "/// Content pattern is \"%s\" (note: not automatically enforced)\n", xstring((*pattern1).value));
+const char *ai = NULL, *ae = NULL, *bi = NULL, *be = NULL;
+if (simpleType.restriction->minInclusive)
+{ ai = simpleType.restriction->minInclusive->value;
+document(simpleType.restriction->minInclusive->annotation);
+}
+else if (simpleType.restriction->minExclusive)
+{ ae = simpleType.restriction->minExclusive->value;
+document(simpleType.restriction->minExclusive->annotation);
+}
+if (simpleType.restriction->maxInclusive)
+{ bi = simpleType.restriction->maxInclusive->value;
+document(simpleType.restriction->maxInclusive->annotation);
+}
+else if (simpleType.restriction->maxExclusive)
+{ be = simpleType.restriction->maxExclusive->value;
+document(simpleType.restriction->maxExclusive->annotation);
+}
+if (ai || ae || bi || be)
+{ fprintf(stream, "/// Value range is ");
+if (ai)
+fprintf(stream, "[%s..", ai);
+else if (ae)
+fprintf(stream, "(%s..", ae);
+else
+fprintf(stream, "[..");
+if (bi)
+fprintf(stream, "%s]\n", bi);
+else if (be)
+fprintf(stream, "%s)\n", be);
+else
+fprintf(stream, "]\n");
+}
+if (!simpleType.restriction->attribute.empty())
+{ if (!Wflag)
+fprintf(stderr, "\nWarning: simpleType '%s' should not have attributes\n", name?name:"");
+}
+const char *s = tname(NULL, baseURI, base);
+if (!anonymous)
+{ bool is_ptr = false;
+is_ptr = (strchr(s, '*') != NULL) || (s == pname(true, NULL, baseURI, base));
+t = deftname(TYPEDEF, NULL, is_ptr, prefix, URI, name);
+if (t)
+fprintf(stream, "typedef %s %s", s, t);
+}
+else
+{ t = "";
+fprintf(stream, elementformat, s, "");
+fprintf(stream, "\n");
+}
+if (t)
+{ if (!anonymous && !simpleType.restriction->pattern.empty())
+{ fprintf(stream, " \"");
+for (vector<xs__pattern>::const_iterator pattern2 = simpleType.restriction->pattern.begin(); pattern2 != simpleType.restriction->pattern.end(); ++pattern2)
+{ if (pattern2 != simpleType.restriction->pattern.begin())
+fprintf(stream, "|");
+fprintf(stream, "%s", xstring((*pattern2).value));
+}
+fprintf(stream, "\"");
+}
+// add range info only when type is numeric
+bool is_numeric = false, is_float = false;
+if (!strncmp(s, "unsigned ", 9))
+s += 9;
+else if (!strncmp(s, "xsd__unsigned", 13))
+s += 13;
+else if (!strncmp(s, "xsd__", 5))
+s += 5;
+if (!strcmp(s, "double")
+|| !strcmp(s, "float"))
+is_numeric = is_float = true;
+else if (!strcmp(s, "bool")
+|| !strcmp(s, "byte")
+|| !strcmp(s, "Byte")
+|| !strcmp(s, "char")
+|| !strcmp(s, "double")
+|| !strcmp(s, "float")
+|| !strcmp(s, "int")
+|| !strcmp(s, "Int")
+|| !strcmp(s, "long")
+|| !strcmp(s, "Long")
+|| !strcmp(s, "LONG64")
+|| !strcmp(s, "short")
+|| !strcmp(s, "Short")
+|| !strcmp(s, "ULONG64"))
+is_numeric = true;
+if (!anonymous
+&& simpleType.restriction->minLength
+&& simpleType.restriction->minLength->value)
+fprintf(stream, " %s", simpleType.restriction->minLength->value);
+else if (is_numeric
+&& !anonymous
+&& simpleType.restriction->minInclusive
+&& simpleType.restriction->minInclusive->value
+&& is_integer(simpleType.restriction->minInclusive->value))
+fprintf(stream, " %s", simpleType.restriction->minInclusive->value);
+else if (is_float
+&& !anonymous
+&& simpleType.restriction->minExclusive
+&& simpleType.restriction->minExclusive->value
+&& is_integer(simpleType.restriction->minExclusive->value))
+fprintf(stream, " %s", simpleType.restriction->minExclusive->value);
+else if (is_numeric
+&& !anonymous
+&& simpleType.restriction->minExclusive
+&& simpleType.restriction->minExclusive->value
+&& is_integer(simpleType.restriction->minExclusive->value))
+fprintf(stream, " " SOAP_LONG_FORMAT, to_integer(simpleType.restriction->minExclusive->value)+1);
+if (!anonymous
+&& simpleType.restriction->maxLength
+&& simpleType.restriction->maxLength->value)
+fprintf(stream, ":%s", simpleType.restriction->maxLength->value);
+else if (is_numeric
+&& !anonymous
+&& simpleType.restriction->maxInclusive
+&& simpleType.restriction->maxInclusive->value
+&& is_integer(simpleType.restriction->maxInclusive->value))
+fprintf(stream, ":%s", simpleType.restriction->maxInclusive->value);
+else if (is_float
+&& !anonymous
+&& simpleType.restriction->maxExclusive
+&& simpleType.restriction->maxExclusive->value
+&& is_integer(simpleType.restriction->maxExclusive->value))
+fprintf(stream, ":%s", simpleType.restriction->maxExclusive->value);
+else if (is_numeric
+&& !anonymous
+&& simpleType.restriction->maxExclusive
+&& simpleType.restriction->maxExclusive->value
+&& is_integer(simpleType.restriction->maxExclusive->value))
+fprintf(stream, ":" SOAP_LONG_FORMAT, to_integer(simpleType.restriction->maxExclusive->value)-1);
+if (!anonymous)
+{ fprintf(stream, ";\n");
+if (pflag && simpleType.name)
+{ const char *s = aname(prefix, URI, name);
+knames.insert(s);
+s = aname(prefix, URI, name);
+fprintf(stream, "\n/// Class wrapper\n");
+fprintf(stream, "class %s : public xsd__anyType\n{ public:\n", s);
+fprintf(stream, elementformat, tname(prefix, URI, name), "__item;");
+modify(s);
+fprintf(stream, "\n};\n");
+}
+}
+}
+}
+}
+}
+else if (simpleType.list)
+{ if (simpleType.list->restriction && simpleType.list->restriction->base)
+{ if (!anonymous)
+{ fprintf(stream, "\n/// \"%s\":%s is a simpleType list restriction of %s.\n", URI?URI:"", name, simpleType.list->restriction->base);
+fprintf(stream, "/// Note: this enumeration is a bitmask, so a set of values is supported (using | and & bit-ops on the bit vector).\n");
+}
+document(simpleType.annotation);
+if (!anonymous)
+{ t = deftname(ENUM, NULL, false, prefix, URI, name);
+if (t)
+fprintf(stream, "enum * %s\n{\n", t);
+}
+else
+{ t = "";
+fprintf(stream, "enum *\n{\n");
+}
+if (t)
+{ for (vector<xs__enumeration>::const_iterator enumeration = simpleType.list->restriction->enumeration.begin(); enumeration != simpleType.list->restriction->enumeration.end(); ++enumeration)
+{ if ((*enumeration).value)
+{ if (!strcmp(simpleType.list->restriction->base, "xs:QName") && (*enumeration).value_)
+fprintf(stream, "\t%s,\t///< %s value=\"%s\"\n", ename(t, (*enumeration).value_, true), simpleType.list->restriction->base, (*enumeration).value_);
+else
+fprintf(stream, "\t%s,\t///< %s value=\"%s\"\n", ename(t, (*enumeration).value, false), simpleType.list->restriction->base, (*enumeration).value);
+}
+else
+fprintf(stream, "//\tunrecognized: bitmask enumeration '%s' has no value\n", t);
+}
+if (!anonymous)
+{ fprintf(stream, "};\n");
+if (yflag)
+fprintf(stream, "/// Typedef synonym for enum %s.\ntypedef enum %s %s;\n", t, t, t);
+if (pflag && simpleType.name)
+{ const char *s = aname(prefix, URI, name);
+knames.insert(s);
+s = aname(prefix, URI, name);
+fprintf(stream, "\n/// Class wrapper\n");
+fprintf(stream, "class %s : public xsd__anyType\n{ public:\n", s);
+fprintf(stream, elementformat, tname(prefix, URI, name), "__item;");
+modify(s);
+fprintf(stream, "\n};\n");
+}
+}
+else
+fprintf(stream, "}\n");
+}
+}
+else if (simpleType.list->itemType)
+{ const xs__simpleType *p = simpleType.list->itemTypePtr();
+if (p
+&& p->restriction
+&& p->restriction->base
+&& !p->restriction->enumeration.empty()
+&& p->restriction->enumeration.size() <= 64)
+{ if (!anonymous)
+{ fprintf(stream, "\n/// \"%s\":%s is a simpleType list of %s.\n", URI?URI:"", name, simpleType.list->itemType);
+fprintf(stream, "/// Note: this enumeration is a bitmask, so a set of values is supported (using | and & bit-ops on the bit vector).\n");
+}
+document(simpleType.annotation);
+if (!anonymous)
+{ t = deftname(ENUM, NULL, false, prefix, URI, name);
+if (t)
+fprintf(stream, "enum * %s\n{\n", t);
+}
+else
+{ t = "";
+fprintf(stream, "enum *\n{\n");
+}
+if (t)
+{ for (vector<xs__enumeration>::const_iterator enumeration = p->restriction->enumeration.begin(); enumeration != p->restriction->enumeration.end(); ++enumeration)
+{ if ((*enumeration).value)
+{ if (!strcmp(p->restriction->base, "xs:QName") && (*enumeration).value_)
+fprintf(stream, "\t%s,\t///< %s value=\"%s\"\n", ename(t, (*enumeration).value_, true), p->restriction->base, (*enumeration).value_);
+else
+fprintf(stream, "\t%s,\t///< %s value=\"%s\"\n", ename(t, (*enumeration).value, false), p->restriction->base, (*enumeration).value);
+}
+else
+fprintf(stream, "//\tunrecognized: bitmask enumeration '%s' has no value\n", t);
+}
+if (!anonymous)
+{ fprintf(stream, "};\n");
+if (yflag)
+fprintf(stream, "/// Typedef synonym for enum %s.\ntypedef enum %s %s;\n", t, t, t);
+if (pflag && simpleType.name)
+{ const char *s = aname(prefix, URI, name);
+knames.insert(s);
+s = aname(prefix, URI, name);
+fprintf(stream, "\n/// Class wrapper.\n");
+fprintf(stream, "class %s : public xsd__anyType\n{ public:\n", s);
+fprintf(stream, elementformat, tname(prefix, URI, name), "__item;");
+modify(s);
+fprintf(stream, "\n};\n");
+}
+}
+else
+fprintf(stream, "}\n");
+}
+}
+else
+{ const char *s;
+if (!strcmp(simpleType.list->itemType, "xs:QName"))
+s = tname(NULL, NULL, "xsd:QName");
+else
+s = tname(NULL, NULL, "xsd:string");
+if (!anonymous)
+{ fprintf(stream, "\n/// \"%s\":%s is a simpleType containing a whitespace separated list of %s.\n", URI?URI:"", name, simpleType.list->itemType);
+t = deftname(TYPEDEF, NULL, strchr(s, '*') != NULL, prefix, URI, name);
+}
+document(simpleType.annotation);
+if (t)
+fprintf(stream, "typedef %s %s;\n", s, t);
+else
+{ fprintf(stream, elementformat, s, "");
+fprintf(stream, "\n");
+}
+}
+}
+else
+{ if (!anonymous)
+{ fprintf(stream, "\n/// \"%s\":%s is a simpleType list.\n", URI?URI:"", name);
+fprintf(stream, "/// Note: this enumeration is a bitmask, so a set of values is supported (using | and & bit-ops on the bit vector).\n");
+}
+document(simpleType.annotation);
+if (!anonymous)
+{ t = deftname(ENUM, NULL, false, prefix, URI, name);
+if (t && !eflag)
+fprintf(stream, "/// Note: enum values are prefixed with '%s' to avoid name clashes, please use wsdl2h option -e to omit this prefix\n", t);
+}
+else
+t = "";
+if (t)
+{ fprintf(stream, "enum * %s\n{\n", t);
+for (vector<xs__simpleType>::const_iterator simple = simpleType.list->simpleType.begin(); simple != simpleType.list->simpleType.end(); ++simple)
+{ if ((*simple).restriction && (*simple).restriction->base)
+{ for (vector<xs__enumeration>::const_iterator enumeration = (*simple).restriction->enumeration.begin(); enumeration != (*simple).restriction->enumeration.end(); ++enumeration)
+{ if ((*enumeration).value)
+{ if (!strcmp((*simple).restriction->base, "xs:QName") && (*enumeration).value_)
+fprintf(stream, "\t%s,\t///< %s value=\"%s\"\n", ename(t, (*enumeration).value_, true), (*simple).restriction->base, (*enumeration).value_);
+else
+fprintf(stream, "\t%s,\t///< %s value=\"%s\"\n", ename(t, (*enumeration).value, false), (*simple).restriction->base, (*enumeration).value);
+}
+else
+fprintf(stream, "//\tunrecognized: bitmask enumeration '%s' has no value\n", t);
+}
+}
+}
+if (!anonymous)
+{ fprintf(stream, "};\n");
+if (yflag)
+fprintf(stream, "/// Typedef synonym for enum %s.\ntypedef enum %s %s;\n", t, t, t);
+if (pflag && simpleType.name)
+{ const char *s = aname(prefix, URI, name);
+knames.insert(s);
+s = aname(prefix, URI, name);
+fprintf(stream, "\n/// Class wrapper.\n");
+fprintf(stream, "class %s : public xsd__anyType\n{ public:\n", s);
+fprintf(stream, elementformat, tname(prefix, URI, name), "__item;");
+modify(s);
+fprintf(stream, "\n};\n");
+}
+}
+else
+fprintf(stream, "}\n");
+}
+}
+}
+else if (simpleType.union_)
+{ if (simpleType.union_->memberTypes)
+{ const char *s = tname(NULL, NULL, "xsd:string");
+if (!anonymous)
+t = deftname(TYPEDEF, NULL, strchr(s, '*') != NULL, prefix, URI, name);
+fprintf(stream, "\n/// union of values \"%s\"\n", simpleType.union_->memberTypes);
+if (t)
+fprintf(stream, "typedef %s %s;\n", s, t);
+else
+{ fprintf(stream, elementformat, s, "");
+fprintf(stream, "\n");
+}
+}
+else if (!simpleType.union_->simpleType.empty())
+{ const char *s = tname(NULL, NULL, "xsd:string");
+fprintf(stream, "\n");
+if (!anonymous)
+t = deftname(TYPEDEF, NULL, strchr(s, '*') != NULL, prefix, URI, name);
+for (vector<xs__simpleType>::const_iterator simpleType1 = simpleType.union_->simpleType.begin(); simpleType1 != simpleType.union_->simpleType.end(); ++simpleType1)
+if ((*simpleType1).restriction)
+{ fprintf(stream, "/// union of values from \"%s\"\n", (*simpleType1).restriction->base);
+// TODO: are there any other types we should report here?
+}
+if (t)
+fprintf(stream, "typedef %s %s;\n", s, t);
+else
+{ fprintf(stream, elementformat, s, "");
+fprintf(stream, "\n");
+}
+}
+else
+fprintf(stream, "//\tunrecognized\n");
+}
+else
+fprintf(stream, "//\tunrecognized simpleType\n");
+}
+void Types::gen(const char *URI, const char *name, const xs__complexType& complexType, bool anonymous)
+{ const char *t = NULL;
+const char *prefix = NULL;
+bool soapflag = false;
+if (complexType.name)
+name = complexType.name;
+else
+prefix = "_";
+if (anonymous && name)
+t = sname(URI, name);
+else if (name)
+{ t = cname(prefix, URI, name);
+if (deftypemap[t])
+return;
+}
+if (name)
+scope.push_back(name);
+if (complexType.simpleContent)
+{ if (!anonymous)
+fprintf(stream, "\n/// \"%s\":%s is a%s complexType with simpleContent.\n", URI?URI:"", name, complexType.abstract?"n abstract":"");
+document(complexType.annotation);
+operations(t);
+if (complexType.simpleContent->restriction)
+{ if (anonymous)
+{ if (cflag)
+fprintf(stream, "    struct %s\n    {\n", t);
+else
+fprintf(stream, "    class %s\n    {\n", t);
+}
+else if (cflag)
+fprintf(stream, "struct %s\n{\n", t);
+else if (pflag && complexType.name)
+fprintf(stream, "class %s : public xsd__anyType\n{ public:\n", t);
+else
+fprintf(stream, "class %s\n{ public:\n", t);
+const char *base = "xs:string";
+const char *baseURI = NULL;
+const xs__complexType *p = &complexType;
+do
+{ if (!p->simpleContent)
+break;
+if (p->simpleContent->restriction)
+{ if (p->simpleContent->restriction->complexTypePtr())
+p = p->simpleContent->restriction->complexTypePtr();
+else
+{ base = p->simpleContent->restriction->base;
+if (p->simpleContent->restriction->simpleTypePtr() && p->simpleContent->restriction->simpleTypePtr()->schemaPtr())
+baseURI = p->simpleContent->restriction->simpleTypePtr()->schemaPtr()->targetNamespace;
+break;
+}
+}
+else if (p->simpleContent->extension)
+{ if (p->simpleContent->extension->complexTypePtr())
+p = p->simpleContent->extension->complexTypePtr();
+else
+{ base = p->simpleContent->extension->base;
+if (p->simpleContent->extension->simpleTypePtr() && p->simpleContent->extension->simpleTypePtr()->schemaPtr())
+baseURI = p->simpleContent->extension->simpleTypePtr()->schemaPtr()->targetNamespace;
+break;
+}
+}
+else
+break;
+}
+while (p);
+fprintf(stream, "/// __item wraps '%s' simpleContent.\n", base);
+fprintf(stream, elementformat, tname(NULL, baseURI, base), "__item");
+fprintf(stream, ";\n");
+p = &complexType;
+bool flag = true;
+do
+{ if (!p->simpleContent)
+break;
+if (p->simpleContent->restriction)
+{ // TODO: should only generate attribute when name is different?
+gen(URI, p->simpleContent->restriction->attribute);
+if (p->simpleContent->restriction->anyAttribute && flag)
+{ gen(URI, *p->simpleContent->restriction->anyAttribute);
+flag = false;
+}
+if (p->simpleContent->restriction->complexTypePtr())
+p = p->simpleContent->restriction->complexTypePtr();
+else
+break;
+}
+else if (p->simpleContent->extension)
+{ gen(URI, p->simpleContent->extension->attribute);
+gen(URI, p->simpleContent->extension->attributeGroup);
+if (p->simpleContent->extension->anyAttribute && flag)
+{ gen(URI, *p->simpleContent->extension->anyAttribute);
+flag = false;
+}
+if (p->simpleContent->extension->complexTypePtr())
+p = p->simpleContent->extension->complexTypePtr();
+else
+break;
+}
+else
+break;
+}
+while (p);
+}
+else if (complexType.simpleContent->extension)
+{ const char *base = "xs:string";
+const char *baseURI = NULL;
+if (cflag || fflag || anonymous)
+{ if (anonymous)
+{ if (cflag)
+fprintf(stream, "    struct %s\n    {\n", t);
+else
+fprintf(stream, "    class %s\n    {\n", t);
+}
+else if (cflag)
+fprintf(stream, "struct %s\n{\n", t);
+else if (pflag && complexType.name)
+fprintf(stream, "class %s : public xsd__anyType\n{ public:\n", t);
+else
+fprintf(stream, "class %s\n{ public:\n", t);
+const xs__complexType *p = &complexType;
+do
+{ if (!p->simpleContent)
+break;
+if (p->simpleContent->restriction)
+{ if (p->simpleContent->restriction->complexTypePtr())
+p = p->simpleContent->restriction->complexTypePtr();
+else
+{ base = p->simpleContent->restriction->base;
+if (p->simpleContent->restriction->simpleTypePtr() && p->simpleContent->restriction->simpleTypePtr()->schemaPtr())
+baseURI = p->simpleContent->restriction->simpleTypePtr()->schemaPtr()->targetNamespace;
+break;
+}
+}
+else if (p->simpleContent->extension)
+{ if (p->simpleContent->extension->complexTypePtr())
+p = p->simpleContent->extension->complexTypePtr();
+else
+{ base = p->simpleContent->extension->base;
+if (p->simpleContent->extension->simpleTypePtr() && p->simpleContent->extension->simpleTypePtr()->schemaPtr())
+baseURI = p->simpleContent->extension->simpleTypePtr()->schemaPtr()->targetNamespace;
+break;
+}
+}
+else
+break;
+}
+while (p);
+fprintf(stream, "/// __item wraps '%s' simpleContent.\n", base);
+fprintf(stream, elementformat, tname(NULL, baseURI, base), "__item");
+fprintf(stream, ";\n");
+p = &complexType;
+bool flag = true;
+do
+{ if (!p->simpleContent)
+break;
+if (p->simpleContent->restriction)
+{ gen(URI, p->simpleContent->restriction->attribute);
+if (p->simpleContent->restriction->anyAttribute && flag)
+gen(URI, *p->simpleContent->restriction->anyAttribute);
+break;
+}
+else if (p->simpleContent->extension)
+{ gen(URI, p->simpleContent->extension->attribute);
+gen(URI, p->simpleContent->extension->attributeGroup);
+if (p->simpleContent->extension->anyAttribute && flag)
+{ gen(URI, *p->simpleContent->extension->anyAttribute);
+flag = false;
+}
+if (p->simpleContent->extension->complexTypePtr())
+p = p->simpleContent->extension->complexTypePtr();
+else
+break;
+}
+else
+break;
+}
+while (p);
+}
+else
+{ base = complexType.simpleContent->extension->base;
+if (
+/* TODO: in future, may want to add check here for base type == class
+complexType.simpleContent->extension->simpleTypePtr()
+||
+*/
+complexType.simpleContent->extension->complexTypePtr())
+{ if (complexType.simpleContent->extension->complexTypePtr()->schemaPtr())
+baseURI = complexType.simpleContent->extension->complexTypePtr()->schemaPtr()->targetNamespace;
+fprintf(stream, "class %s : public %s\n{ public:\n", t, cname(NULL, baseURI, base));
+soapflag = true;
+}
+else
+{ if (complexType.simpleContent->extension->simpleTypePtr() && complexType.simpleContent->extension->simpleTypePtr()->schemaPtr())
+baseURI = complexType.simpleContent->extension->simpleTypePtr()->schemaPtr()->targetNamespace;
+else if (complexType.simpleContent->extension->complexTypePtr() && complexType.simpleContent->extension->complexTypePtr()->schemaPtr())
+baseURI = complexType.simpleContent->extension->complexTypePtr()->schemaPtr()->targetNamespace;
+if (pflag && complexType.name)
+fprintf(stream, "class %s : public xsd__anyType\n{ public:\n", t);
+else
+fprintf(stream, "class %s\n{ public:\n", t);
+fprintf(stream, "/// __item wraps '%s' simpleContent.\n", base);
+fprintf(stream, elementformat, tname(NULL, baseURI, base), "__item");
+fprintf(stream, ";\n");
+}
+gen(URI, complexType.simpleContent->extension->attribute);
+gen(URI, complexType.simpleContent->extension->attributeGroup);
+if (complexType.simpleContent->extension->anyAttribute)
+gen(URI, *complexType.simpleContent->extension->anyAttribute);
+}
+}
+else
+fprintf(stream, "//\tunrecognized\n");
+}
+else if (complexType.complexContent)
+{ if (complexType.complexContent->restriction)
+{ if (!anonymous)
+fprintf(stream, "\n/// \"%s\":%s is a%s complexType with complexContent restriction of %s.\n", URI?URI:"", name, complexType.abstract?"n abstract":"", complexType.complexContent->restriction->base);
+document(complexType.annotation);
+operations(t);
+if (!strcmp(complexType.complexContent->restriction->base, "SOAP-ENC:Array"))
+{ char *item = NULL, *type = NULL;
+if (!complexType.complexContent->restriction->attribute.empty())
+{ xs__attribute& attribute = complexType.complexContent->restriction->attribute.front();
+if (attribute.wsdl__arrayType)
+type = attribute.wsdl__arrayType;
+}
+xs__seqchoice *s = complexType.complexContent->restriction->sequence;
+if (s
+&& !s->__contents.empty()
+&& s->__contents.front().__union == SOAP_UNION_xs__union_content_element
+&& s->__contents.front().__content.element)
+{ xs__element& element = *s->__contents.front().__content.element;
+if (!type)
+{ if (element.type)
+type = element.type;
+else if (element.simpleTypePtr())
+{ if (element.simpleTypePtr()->name)
+type = element.simpleTypePtr()->name;
+else if (element.simpleTypePtr()->restriction)
+type = element.simpleTypePtr()->restriction->base;
+}
+else if (element.complexTypePtr())
+{ if (element.complexTypePtr()->name)
+type = element.complexTypePtr()->name;
+else if (element.complexTypePtr()->complexContent && element.complexTypePtr()->complexContent->restriction)
+type = element.complexTypePtr()->complexContent->restriction->base;
+}
+}
+item = element.name; // <sequence><element name="item" type="..."/></sequence>
+}
+gen_soap_array(name, t, item, type);
+}
+else
+{ if (anonymous)
+{ if (cflag)
+fprintf(stream, "    struct %s\n    {\n", t);
+else
+fprintf(stream, "    class %s\n    {\n", t);
+}
+else if (cflag)
+fprintf(stream, "struct %s\n{\n", t);
+else if (pflag && complexType.name)
+fprintf(stream, "class %s : public xsd__anyType\n{ public:\n", t);
+else
+fprintf(stream, "class %s\n{ public:\n", t);
+if (complexType.complexContent->restriction->group)
+gen(URI, *complexType.complexContent->restriction->group, NULL, NULL);
+if (complexType.complexContent->restriction->all)
+gen(URI, *complexType.complexContent->restriction->all, NULL, NULL);
+if (complexType.complexContent->restriction->sequence)
+gen(URI, *complexType.complexContent->restriction->sequence, NULL, NULL);
+if (complexType.complexContent->restriction->choice)
+gen(URI, name, *complexType.complexContent->restriction->choice, NULL, NULL);
+gen(URI, complexType.complexContent->restriction->attribute);
+	bool flag = true;
+if (complexType.complexContent->restriction->anyAttribute)
+{ gen(URI, *complexType.complexContent->restriction->anyAttribute);
+	  flag = false;
+	}
+const xs__complexType *p = complexType.complexContent->restriction->complexTypePtr();
+while (p)
+{ const char *pURI;
+	  if (p->schemaPtr())
+pURI = p->schemaPtr()->targetNamespace;
+else
+pURI = URI;
+const char *b = cname(NULL, pURI, p->name);
+if (zflag && zflag <= 5)
+fprintf(stream, "/// RESTRICTED FROM %s:\n", b);
+else if (comment_nest == 0)
+fprintf(stream, "/*  RESTRICTED FROM %s:\n", b);
+else
+fprintf(stream, "    RESTRICTED FROM %s:\n", b);
+comment_nest++;
+if (p->complexContent && p->complexContent->restriction)
+{ gen(URI, p->complexContent->restriction->attribute);
+if (p->complexContent->restriction->anyAttribute && flag)
+{ gen(URI, *p->complexContent->restriction->anyAttribute);
+flag = false;
+}
+p = p->complexContent->restriction->complexTypePtr();
+}
+else if (p->complexContent && p->complexContent->extension)
+{ gen(URI, p->complexContent->extension->attribute);
+gen(URI, p->complexContent->extension->attributeGroup);
+if (p->complexContent->extension->anyAttribute && flag)
+{ gen(URI, *p->complexContent->extension->anyAttribute);
+flag = false;
+}
+p = p->complexContent->extension->complexTypePtr();
+}
+else
+{ gen(URI, p->attribute);
+gen(URI, p->attributeGroup);
+if (p->anyAttribute && flag)
+gen(URI, *p->anyAttribute);
+p = NULL;
+}
+	  comment_nest--;
+if (zflag && zflag <= 5)
+fprintf(stream, "//  END OF RESTRICTED FROM %s\n", b);
+else if (comment_nest == 0)
+fprintf(stream, "    END OF RESTRICTED FROM %s */\n", b);
+else
+fprintf(stream, "    END OF RESTRICTED FROM %s\n", b);
+}
+}
+}
+else if (complexType.complexContent->extension)
+{ const char *base = complexType.complexContent->extension->base;
+xs__complexType *p = complexType.complexContent->extension->complexTypePtr();
+if (!anonymous)
+fprintf(stream, "\n/// \"%s\":%s is a%s complexType with complexContent extension of %s.\n", URI?URI:"", name, complexType.abstract?"n abstract":"", base);
+document(complexType.annotation);
+operations(t);
+if (anonymous)
+{ if (cflag)
+fprintf(stream, "    struct %s\n    {\n", t);
+else
+fprintf(stream, "    class %s\n    {\n", t);
+}
+else if (cflag)
+fprintf(stream, "struct %s\n{\n", t);
+else if (fflag)
+fprintf(stream, "class %s\n{ public:\n", t);
+else // TODO: what to do if base class is in another namespace and elements must be qualified in XML payload?
+{ const char *baseURI = NULL;
+if (p && p->schemaPtr())
+baseURI = p->schemaPtr()->targetNamespace;
+fprintf(stream, "class %s : public %s\n{ public:\n", t, cname(NULL, baseURI, base));
+soapflag = true;
+}
+gen_inh(URI, p, anonymous);
+if (complexType.complexContent->extension->group)
+gen(URI, *complexType.complexContent->extension->group, NULL, NULL);
+if (complexType.complexContent->extension->all)
+gen(URI, *complexType.complexContent->extension->all, NULL, NULL);
+if (complexType.complexContent->extension->sequence)
+gen(URI, *complexType.complexContent->extension->sequence, NULL, NULL);
+if (complexType.complexContent->extension->choice)
+gen(URI, name, *complexType.complexContent->extension->choice, NULL, NULL);
+gen(URI, complexType.complexContent->extension->attribute);
+gen(URI, complexType.complexContent->extension->attributeGroup);
+if (complexType.complexContent->extension->anyAttribute)
+gen(URI, *complexType.complexContent->extension->anyAttribute);
+}
+else
+fprintf(stream, "//\tunrecognized\n");
+}
+else
+{ if (!anonymous)
+fprintf(stream, "\n/// \"%s\":%s is a%s complexType.\n", URI?URI:"", name, complexType.abstract?"n abstract":"");
+document(complexType.annotation);
+operations(t);
+if (anonymous)
+{ if (cflag)
+fprintf(stream, "    struct %s\n    {\n", t);
+else
+fprintf(stream, "    class %s\n    {\n", t);
+}
+else if (cflag)
+fprintf(stream, "struct %s\n{\n", t);
+else if (pflag && complexType.name)
+fprintf(stream, "class %s : public xsd__anyType\n{ public:\n", t);
+else
+fprintf(stream, "class %s\n{ public:\n", t);
+if (complexType.all)
+gen(URI, *complexType.all, NULL, NULL);
+else if (complexType.choice)
+gen(URI, name, *complexType.choice, NULL, NULL);
+else if (complexType.sequence)
+gen(URI, *complexType.sequence, NULL, NULL);
+else if (complexType.any)
+gen(URI, *complexType.any, NULL, NULL);
+}
+gen(URI, complexType.attribute);
+gen(URI, complexType.attributeGroup);
+if (complexType.anyAttribute)
+gen(URI, *complexType.anyAttribute);
+if (complexType.mixed
+|| (   complexType.complexContent
+&& complexType.complexContent->extension
+&& complexType.complexContent->extension->complexTypePtr()
+&& complexType.complexContent->extension->complexTypePtr()->mixed
+))
+{ fprintf(stream, "/// TODO: this mixed complexType is user-definable.\n///       Consult the protocol documentation to change or insert declarations.\n///       Use wsdl2h option -d for xsd__anyType DOM (soap_dom_element).\n");
+if (dflag)
+{ if (with_union)
+fprintf(stream, pointerformat, "xsd__anyType", "__mixed");
+else
+fprintf(stream, elementformat, "xsd__anyType", "__mixed");
+fprintf(stream, "0;\t///< Catch mixed content in DOM soap_dom_element linked node structure.\n");
+}
+else
+{ fprintf(stream, elementformat, "_XML", "__mixed");
+fprintf(stream, "0;\t///< Catch mixed content in XML string\n");
+}
+}
+if (t)
+modify(t);
+if (!anonymous)
+{ if (!cflag
+&& !(pflag && complexType.name)
+&& !soapflag)
+{ if (!complexType.complexContent || !complexType.complexContent->extension || !complexType.complexContent->extension->complexTypePtr())
+{ fprintf(stream, "/// A handle to the soap struct that manages this instance (automatically set)\n");
+fprintf(stream, pointerformat, "struct soap", "soap");
+fprintf(stream, ";\n");
+}
+}
+fprintf(stream, "};\n");
+}
+scope.pop_back();
+}
+void Types::gen(const char *URI, const vector<xs__attribute>& attributes)
+{ for (vector<xs__attribute>::const_iterator attribute = attributes.begin(); attribute != attributes.end(); ++attribute)
+gen(URI, *attribute);
+}
+void Types::gen(const char *URI, const xs__attribute& attribute)
+{ const char *name, *type, *nameURI = NULL, *typeURI = NULL, *nameprefix = NULL, *typeprefix = NULL;
+name = attribute.name;
+type = attribute.type;
+bool is_optional = attribute.use != required && attribute.use != default_ && attribute.use != fixed_ && !attribute.default_;
+document(attribute.annotation);
+if (!URI)
+URI = attribute.schemaPtr()->targetNamespace;
+if (attribute.form)
+{ if (*attribute.form == qualified)
+nameURI = URI;
+else
+nameprefix = ":";
+}
+if (URI && attribute.schemaPtr() && attribute.schemaPtr()->targetNamespace && strcmp(URI,  attribute.schemaPtr()->targetNamespace))
+nameURI = attribute.schemaPtr()->targetNamespace; // handles attributeGroup defined in another namespace
+if (attribute.attributePtr()) // attribute ref
+{ name = attribute.attributePtr()->name;
+type = attribute.attributePtr()->type;
+if (!type)
+{ type = name;
+typeprefix = "_";
+}
+if (attribute.attributePtr()->schemaPtr())
+{ typeURI = attribute.attributePtr()->schemaPtr()->targetNamespace;
+if (attribute.form && *attribute.form == unqualified)
+nameprefix = ":";
+else if (zflag != 3 && zflag != 2
+&& URI
+&& typeURI
+&& attribute.schemaPtr()->elementFormDefault == qualified
+&& !strcmp(URI, typeURI))
+nameprefix = NULL;
+else if (zflag == 3
+&& URI
+&& typeURI
+&& attribute.schemaPtr()->attributeFormDefault == unqualified
+&& !strcmp(URI, typeURI))
+nameprefix = NULL;
+else
+nameURI = typeURI;
+}
+fprintf(stream, "/// Attribute reference %s.\n", attribute.ref);
+document(attribute.attributePtr()->annotation);
+fprintf(stream, attributeformat, pname(is_optional, typeprefix, typeURI, type), aname(nameprefix, nameURI, name)); // make sure no name - type clash
+}
+else if (name && type)
+{ fprintf(stream, "/// Attribute %s of type %s.\n", name, type);
+fprintf(stream, attributeformat, pname(is_optional, NULL, URI, type), aname(nameprefix, nameURI, name)); // make sure no name - type clash
+}
+else if (name && attribute.simpleTypePtr())
+{ fprintf(stream, "@");
+gen(URI, name, *attribute.simpleTypePtr(), true);
+// 8/1/09 Changed (is_optional && !cflag && !sflag) to is_optional
+fprintf(stream, is_optional ? pointerformat : elementformat, "", aname(nameprefix, nameURI, name));
+}
+else if (attribute.ref)
+{ fprintf(stream, "/// Imported attribute reference %s.\n", attribute.ref);
+fprintf(stream, attributeformat, pname(is_optional, "_", NULL, attribute.ref), aname(NULL, NULL, attribute.ref));
+}
+else
+{ fprintf(stream, "/// Attribute '%s' has no type or ref: assuming string content.\n", name?name:"");
+fprintf(stream, attributeformat, tname(NULL, NULL, "xs:string"), aname(NULL, nameURI, name));
+}
+switch (attribute.use)
+{ case prohibited:
+fprintf(stream, " 0:0");
+break;
+case required:
+fprintf(stream, " 1");
+break;
+default:
+fprintf(stream, " 0");
+break;
+}
+if (attribute.default_
+|| (attribute.fixed && !is_optional))
+{ const char *value, *QName;
+if (attribute.default_)
+{ value = attribute.default_;
+QName = attribute.default__;
+}
+else
+{ value = attribute.fixed;
+QName = attribute.fixed_;
+}
+const char *t = NULL;
+if (!type && attribute.simpleTypePtr())
+{ if (attribute.simpleTypePtr()->restriction && attribute.simpleTypePtr()->restriction->base)
+{ if (!attribute.simpleTypePtr()->restriction->enumeration.empty())
+{ const char *s;
+if (is_integer(value))
+fprintf(stream, " = %s", value);
+else if (!*value)
+fprintf(stream, " = 0");
+else if ((s = enames[Pair(gname(URI, name),value)]))
+fprintf(stream, " = %s", s);
+}
+else
+{ const char *baseURI = NULL;
+if (attribute.simpleTypePtr()->restriction->simpleTypePtr() && attribute.simpleTypePtr()->restriction->simpleTypePtr()->schemaPtr())
+baseURI = attribute.simpleTypePtr()->restriction->simpleTypePtr()->schemaPtr()->targetNamespace;
+t = tname(NULL, baseURI, attribute.simpleTypePtr()->restriction->base);
+}
+}
+}
+if (type && !t)
+t = tname(NULL, typeURI?typeURI:URI, type);
+if (t)
+{ if (!strncmp(t, "unsigned ", 9))
+t += 9;
+else if (!strncmp(t, "xsd__unsigned", 13))
+t += 13;
+else if (!strncmp(t, "xsd__", 5))
+t += 5;
+if (!strcmp(t, "bool")
+|| !strcmp(t, "byte")
+|| !strcmp(t, "Byte")
+|| !strcmp(t, "char")
+|| !strcmp(t, "double")
+|| !strcmp(t, "float")
+|| !strcmp(t, "int")
+|| !strcmp(t, "Int")
+|| !strcmp(t, "long")
+|| !strcmp(t, "Long")
+|| !strcmp(t, "LONG64")
+|| !strcmp(t, "short")
+|| !strcmp(t, "Short")
+|| !strcmp(t, "ULONG64"))
+fprintf(stream, " = %s", value);
+else if (!strncmp(t, "enum ", 5))
+{ const char *s;
+if (is_integer(value))
+fprintf(stream, " = %s", value);
+else if (!*value)
+fprintf(stream, " = 0");
+else if ((s = enames[Pair(t + 5,value)]))
+fprintf(stream, " = %s", s);
+}
+else if (!strcmp(t, "char*")
+|| !strcmp(t, "char *")	// not elegant
+|| !strcmp(t, "std::string")
+|| !strcmp(t, "std::string*")
+|| !strcmp(t, "std::string *"))	// not elegant
+fprintf(stream, " = \"%s\"", cstring(value));
+else if (!strcmp(t, "xsd__QName") && QName)	// QName
+fprintf(stream, " = \"%s\"", cstring(QName));
+}
+if (attribute.default_)
+fprintf(stream, ";\t///< Default value=\"%s\".\n", value);
+else
+fprintf(stream, ";\t///< Fixed required value=\"%s\".\n", value);
+}
+else if (attribute.fixed)
+fprintf(stream, ";\t///< Fixed optional value=\"%s\".\n", attribute.fixed);
+else if (attribute.use == required)
+fprintf(stream, ";\t///< Required attribute.\n");
+else if (attribute.use == prohibited)
+fprintf(stream, ";\t///< Prohibited attribute.\n");
+else
+fprintf(stream, ";\t///< Optional attribute.\n");
+}
+void Types::gen(const char *URI, const vector<xs__attributeGroup>& attributeGroups)
+{ for (vector<xs__attributeGroup>::const_iterator attributeGroup = attributeGroups.begin(); attributeGroup != attributeGroups.end(); ++attributeGroup)
+{ const xs__attributeGroup *ag = &*attributeGroup;
+if (ag->attributeGroupPtr()) // attributeGroup ref
+ag = ag->attributeGroupPtr();
+fprintf(stream, "/// Begin attributeGroup %s.\n", ag->name?ag->name:ag->ref?ag->ref:"");
+gen(URI, ag->attribute);
+gen(URI, ag->attributeGroup);
+if (ag->anyAttribute)
+gen(URI, *ag->anyAttribute);
+fprintf(stream, "/// End of attributeGroup %s.\n", ag->name?ag->name:ag->ref?ag->ref:"");
+}
+}
+void Types::gen(const char *URI, const vector<xs__all>& alls)
+{ for (vector<xs__all>::const_iterator all = alls.begin(); all != alls.end(); ++all)
+gen(URI, *all, NULL, NULL);
+}
+void Types::gen(const char *URI, const xs__all& all, const char *minOccurs, const char *maxOccurs)
+{ bool tmp_union1 = with_union;
+bool tmp_union2 = fake_union;
+with_union = false;
+fake_union = false;
+gen(URI, all.element, minOccurs, maxOccurs);
+with_union = tmp_union1;
+fake_union = tmp_union2;
+}
+void Types::gen(const char *URI, const vector<xs__contents>& contents)
+{ for (vector<xs__contents>::const_iterator content = contents.begin(); content != contents.end(); ++content)
+{ switch ((*content).__union)
+{ case SOAP_UNION_xs__union_content_element:
+if ((*content).__content.element)
+gen(URI, *(*content).__content.element, true, NULL, NULL);
+break;
+case SOAP_UNION_xs__union_content_group:
+if ((*content).__content.group)
+gen(URI, *(*content).__content.group, NULL, NULL);
+break;
+case SOAP_UNION_xs__union_content_choice:
+if ((*content).__content.choice)
+gen(URI, NULL, *(*content).__content.choice, NULL, NULL);
+break;
+case SOAP_UNION_xs__union_content_sequence:
+if ((*content).__content.sequence)
+gen(URI, *(*content).__content.sequence, NULL, NULL);
+break;
+case SOAP_UNION_xs__union_content_any:
+if ((*content).__content.any)
+gen(URI, *(*content).__content.any, NULL, NULL);
+break;
+}
+}
+}
+void Types::gen(const char *URI, const xs__seqchoice& sequence, const char *minOccurs, const char *maxOccurs)
+{ const char *s = NULL;
+char *t = NULL;
+bool tmp_union = with_union;
+with_union = false;
+if (sequence.minOccurs)
+minOccurs = sequence.minOccurs;
+if (sequence.maxOccurs)
+maxOccurs = sequence.maxOccurs;
+if ((minOccurs && strcmp(minOccurs, "1"))
+|| (maxOccurs && strcmp(maxOccurs, "1")))
+{ fprintf(stream, "/// SEQUENCE <xs:sequence");
+if (minOccurs)
+fprintf(stream, " minOccurs=\"%s\"", minOccurs);
+if (maxOccurs)
+fprintf(stream, " maxOccurs=\"%s\"", maxOccurs);
+fprintf(stream, ">\n");
+document(sequence.annotation);
+s = sname(URI, "sequence");
+t = (char*)emalloc(strlen(s)+2);
+strcpy(t, "_");
+strcat(t, s);
+s = strstr(s, "__");
+if (!s)
+s = t;
+if (cflag || sflag || zflag == 2)
+{ fprintf(stream, sizeformat, "int", s + 1);
+if (!fake_union && minOccurs)
+fprintf(stream, " %s", minOccurs);
+if (maxOccurs
+&& strcmp(maxOccurs, "1")
+&& is_integer(maxOccurs))
+fprintf(stream, ":%s", maxOccurs);
+fprintf(stream, ";\n");
+}
+else
+{ fprintf(stream, elementformat, "std::vector<", "");
+fprintf(stream, "\n");
+}
+if (cflag)
+fprintf(stream, "    struct %s\n    {\n", t);
+else
+fprintf(stream, "    class %s\n    {\n", t);
+}
+else
+{ if (fake_union)
+fprintf(stream, "/// SEQUENCE <xs:sequence>\n");
+document(sequence.annotation);
+}
+gen(URI, sequence.__contents);
+if (s)
+{ if (cflag || sflag || zflag == 2)
+fprintf(stream, pointerformat, "}", s);
+else
+{ fprintf(stream, elementformat, "}>", s);
+if (!fake_union && minOccurs)
+fprintf(stream, " %s", minOccurs);
+if (maxOccurs
+&& strcmp(maxOccurs, "1")
+&& is_integer(maxOccurs))
+fprintf(stream, ":%s", maxOccurs);
+}
+fprintf(stream, ";\n");
+}
+if (s || fake_union)
+fprintf(stream, "//  END OF SEQUENCE\n");
+with_union = tmp_union;
+}
+void Types::gen(const char *URI, const vector<xs__element>& elements, const char *minOccurs, const char *maxOccurs)
+{ for (vector<xs__element>::const_iterator element = elements.begin(); element != elements.end(); ++element)
+gen(URI, *element, true, minOccurs, maxOccurs);
+}
+void Types::gen(const char *URI, const xs__element& element, bool substok, const char *minOccurs, const char *maxOccurs)
+{ const char *name, *type, *nameURI = NULL, *typeURI = NULL, *nameprefix = NULL, *typeprefix = NULL;
+name = element.name;
+type = element.type;
+document(element.annotation);
+if (!URI)
+URI = element.schemaPtr()->targetNamespace;
+if (element.minOccurs)
+minOccurs = element.minOccurs;
+if (element.maxOccurs)
+maxOccurs = element.maxOccurs;
+if (element.xmime__expectedContentTypes)
+fprintf(stream, "/// MTOM attachment with content types %s.\n", element.xmime__expectedContentTypes);
+if (element.form)
+{ if (*element.form == qualified)
+nameURI = URI;
+else
+nameprefix = ":";
+}
+if (element.elementPtr()) // element ref
+{ name = element.elementPtr()->name;
+type = element.elementPtr()->type;
+if (!type)
+{ type = name;
+typeprefix = "_";
+}
+if (element.elementPtr()->schemaPtr())
+{ typeURI = element.elementPtr()->schemaPtr()->targetNamespace;
+if (element.form && *element.form == unqualified)
+nameprefix = ":";
+else if (zflag != 3 && zflag != 2
+&& URI
+&& typeURI
+&& element.schemaPtr()->elementFormDefault == qualified
+&& !strcmp(URI, typeURI))
+nameprefix = NULL;
+else if (zflag == 3
+&& URI
+&& typeURI
+&& element.schemaPtr()->elementFormDefault == unqualified
+&& !strcmp(URI, typeURI))
+nameprefix = NULL;
+else
+nameURI = typeURI;
+}
+document(element.elementPtr()->annotation);
+if (element.elementPtr()->xmime__expectedContentTypes)
+fprintf(stream, "/// MTOM attachment with content types %s.\n", element.elementPtr()->xmime__expectedContentTypes);
+if (substok && element.elementPtr()->abstract)
+{ fprintf(stream, "/// Reference %s to abstract element.\n", element.ref);
+gen_substitutions(URI, element);
+}
+else if (substok
+&& element.elementPtr()->substitutionsPtr()
+&& !element.elementPtr()->substitutionsPtr()->empty())
+{ if (vflag)
+fprintf(stderr, "\nWarning: element ref '%s' stands as the head of a substitutionGroup but is not declared abstract\n", element.ref);
+gen_substitutions(URI, element);
+}
+else if (maxOccurs && strcmp(maxOccurs, "1")) // maxOccurs != "1"
+{ const char *s = tnameptr(cflag && zflag != 1, typeprefix, typeURI, type);
+if (cflag || sflag)
+{ fprintf(stream, "/// Size of the dynamic array of %s is %s..%s\n", s, minOccurs ? minOccurs : "1", maxOccurs);
+fprintf(stream, sizeformat, "int", aname(NULL, NULL, name));
+fprintf(stream, " %s", fake_union ? "0" : minOccurs ? minOccurs : "1");
+if (is_integer(maxOccurs))
+fprintf(stream, ":%s", maxOccurs);
+fprintf(stream, ";\n");
+if (cflag && zflag != 1)
+{ fprintf(stream, "/// Array %s of length %s..%s\n", s, minOccurs ? minOccurs : "1", maxOccurs);
+fprintf(stream, elementformat, s, aname(nameprefix, nameURI, name));
+}
+else
+{ fprintf(stream, "/// Pointer to array %s of length %s..%s\n", s, minOccurs ? minOccurs : "1", maxOccurs);
+fprintf(stream, pointerformat, s, aname(nameprefix, nameURI, name));
+}
+}
+else
+{ fprintf(stream, "/// Vector of %s element refs with length %s..%s\n", s, minOccurs ? minOccurs : "1", maxOccurs);
+if (with_union)
+fprintf(stream, pointervectorformat, s, aname(nameprefix, nameURI, name));
+else
+fprintf(stream, vectorformat, s, aname(nameprefix, nameURI, name));
+}
+}
+else
+{ fprintf(stream, "/// Element reference %s.\n", element.ref);
+fprintf(stream, elementformat, pname((with_union && !cflag && !is_basetypeforunion(typeprefix, typeURI, type)) || fake_union || is_nillable(element), typeprefix, typeURI, type), aname(nameprefix, nameURI, name));
+}
+}
+else if (name && type)
+{ if (substok && element.abstract)
+{ fprintf(stream, "/// Abstract element %s of type %s.\n", name, type);
+gen_substitutions(URI, element);
+}
+else if (substok
+&& element.substitutionsPtr()
+&& !element.substitutionsPtr()->empty())
+{ if (vflag)
+fprintf(stderr, "\nWarning: element '%s' stands as the head of a substitutionGroup but is not declared abstract\n", name);
+gen_substitutions(URI, element);
+}
+else if (maxOccurs && strcmp(maxOccurs, "1")) // maxOccurs != "1"
+{ const char *s = tnameptr(cflag && zflag != 1, NULL, URI, type);
+if (cflag || sflag)
+{ fprintf(stream, "/// Size of array of %s is %s..%s\n", s, minOccurs ? minOccurs : "1", maxOccurs);
+fprintf(stream, sizeformat, "int", aname(NULL, NULL, name));
+fprintf(stream, " %s", fake_union ? "0" : minOccurs ? minOccurs : "1");
+if (is_integer(maxOccurs))
+fprintf(stream, ":%s", maxOccurs);
+fprintf(stream, ";\n");
+if (cflag && zflag != 1)
+{ fprintf(stream, "/// Array %s of length %s..%s\n", s, minOccurs ? minOccurs : "1", maxOccurs);
+fprintf(stream, elementformat, s, aname(nameprefix, nameURI, name));
+}
+else
+{ fprintf(stream, "/// Pointer to array %s of length %s..%s\n", s, minOccurs ? minOccurs : "1", maxOccurs);
+fprintf(stream, pointerformat, s, aname(nameprefix, nameURI, name));
+}
+}
+else
+{ fprintf(stream, "/// Vector of %s with length %s..%s\n", s, minOccurs ? minOccurs : "1", maxOccurs);
+if (with_union)
+fprintf(stream, pointervectorformat, s, aname(nameprefix, nameURI, name));
+else
+fprintf(stream, vectorformat, s, aname(nameprefix, nameURI, name));
+}
+}
+else
+{ fprintf(stream, "/// Element %s of type %s.\n", name, type);
+fprintf(stream, elementformat, pname((with_union && !cflag && !is_basetypeforunion(NULL, URI, type)) || (fake_union && !element.default_) || is_nillable(element), NULL, URI, type), aname(nameprefix, nameURI, name));
+}
+}
+else if (name && element.simpleTypePtr())
+{ const char *s = "";
+document(element.simpleTypePtr()->annotation);
+if (maxOccurs && strcmp(maxOccurs, "1")) // maxOccurs != "1"
+{ if (cflag || sflag)
+{ fprintf(stream, "/// Size of %s array is %s..%s\n", name, minOccurs ? minOccurs : "1", maxOccurs);
+fprintf(stream, sizeformat, "int", aname(NULL, NULL, name));
+fprintf(stream, " %s", fake_union ? "0" : minOccurs ? minOccurs : "1");
+if (is_integer(maxOccurs))
+fprintf(stream, ":%s", maxOccurs);
+fprintf(stream, ";\n");
+}
+else
+{ s = ">";
+fprintf(stream, "/// Vector of %s with length %s..%s\n", name, minOccurs ? minOccurs : "1", maxOccurs);
+fprintf(stream, vectorformat_open, "\n");
+}
+}
+gen(URI, name, *element.simpleTypePtr(), true);
+if (is_nillable(element)
+|| ((cflag || sflag ) && maxOccurs && strcmp(maxOccurs, "1")) // maxOccurs != "1"
+|| (with_union && !cflag)
+|| (fake_union && !element.default_))
+fprintf(stream, pointerformat, s, aname(nameprefix, nameURI, name));
+else
+fprintf(stream, elementformat, s, aname(nameprefix, nameURI, name));
+}
+else if (name && element.complexTypePtr())
+{ const char *s = "}";
+document(element.complexTypePtr()->annotation);
+if (maxOccurs && strcmp(maxOccurs, "1")) // maxOccurs != "1"
+{ if (cflag || sflag)
+{ fprintf(stream, "/// Size of %s array is %s..%s\n", name, minOccurs ? minOccurs : "1", maxOccurs);
+fprintf(stream, sizeformat, "int", aname(NULL, NULL, name));
+fprintf(stream, " %s", fake_union ? "0" : minOccurs ? minOccurs : "1");
+if (is_integer(maxOccurs))
+fprintf(stream, ":%s", maxOccurs);
+fprintf(stream, ";\n");
+}
+else
+{ s = "}>";
+fprintf(stream, "/// Vector of %s with length %s..%s\n", name, minOccurs ? minOccurs : "1", maxOccurs);
+fprintf(stream, vectorformat_open, "\n");
+}
+}
+gen(URI, name, *element.complexTypePtr(), true);
+if (is_nillable(element)
+|| ((cflag || sflag ) && maxOccurs && strcmp(maxOccurs, "1")) // maxOccurs != "1"
+|| (with_union && !cflag)
+|| (fake_union && !element.default_))
+fprintf(stream, pointerformat, s, aname(nameprefix, nameURI, name));
+else
+fprintf(stream, elementformat, s, aname(nameprefix, nameURI, name));
+}
+else if (element.ref)
+{ fprintf(stream, "/// Imported element reference %s.\n", element.ref);
+if (maxOccurs && strcmp(maxOccurs, "1")) // maxOccurs != "1"
+{ if (cflag || sflag)
+{ fprintf(stream, "/// Size of %s array is %s..%s\n", element.ref, minOccurs ? minOccurs : "1", maxOccurs);
+fprintf(stream, sizeformat, "int", aname(NULL, NULL, element.ref));
+fprintf(stream, " %s", fake_union ? "0" : minOccurs ? minOccurs : "1");
+if (is_integer(maxOccurs))
+fprintf(stream, ":%s", maxOccurs);
+fprintf(stream, ";\n");
+fprintf(stream, pointerformat, pname(true, "_", NULL, element.ref), aname(nameprefix, nameURI, element.ref));
+}
+else
+{ fprintf(stream, "/// Vector of %s with length %s..%s\n", element.ref, minOccurs ? minOccurs : "1", maxOccurs);
+fprintf(stream, vectorformat, pname(false, "_", NULL, element.ref), aname(nameprefix, nameURI, element.ref));
+}
+}
+else
+fprintf(stream, elementformat, pname((with_union && !cflag) || fake_union || is_nillable(element), "_", NULL, element.ref), aname(nameprefix, nameURI, element.ref));
+}
+else if (name)
+{ fprintf(stream, "/// Element '%s' has no type or ref (empty or with XML content).\n", name?name:"");
+if (maxOccurs && strcmp(maxOccurs, "1")) // maxOccurs != "1"
+{ if (cflag || sflag)
+{ fprintf(stream, sizeformat, "int", aname(NULL, NULL, name));
+fprintf(stream, " %s", fake_union ? "0" : minOccurs ? minOccurs : "1");
+if (is_integer(maxOccurs))
+fprintf(stream, ":%s", maxOccurs);
+fprintf(stream, ";\n");
+fprintf(stream, "/// Pointer to array of XML.\n");
+fprintf(stream, pointerformat, "_XML", aname(NULL, nameURI, name));
+}
+else
+{ fprintf(stream, "/// Vector of XML with length %s..%s\n", minOccurs ? minOccurs : "1", maxOccurs);
+if (with_union)
+fprintf(stream, pointervectorformat, "_XML", aname(NULL, nameURI, name));
+else
+fprintf(stream, vectorformat, "_XML", aname(NULL, nameURI, name));
+}
+}
+else
+fprintf(stream, elementformat, "_XML", aname(NULL, nameURI, name));
+}
+else
+fprintf(stream, "/// Element has no name, type, or ref.");
+if (!substok
+|| (   !(element.elementPtr() && element.elementPtr()->abstract)
+&& !(element.substitutionsPtr() && !element.substitutionsPtr()->empty())
+&& !(element.elementPtr() && element.elementPtr()->substitutionsPtr() && !element.elementPtr()->substitutionsPtr()->empty())
+))
+{ if (!fake_union && !minOccurs && !element.nillable && !element.default_ && !element.abstract)
+fprintf(stream, " 1");
+else if (!fake_union && minOccurs)
+fprintf(stream, " %s", minOccurs);
+if (maxOccurs && strcmp(maxOccurs, "1") && is_integer(maxOccurs))
+fprintf(stream, ":%s", maxOccurs);
+if (element.default_
+|| (   element.fixed
+&& !fake_union
+&& (!minOccurs || !strcmp(minOccurs, "1"))
+&& (!maxOccurs || !strcmp(maxOccurs, "1"))
+))
+{ // determine whether the element can be assigned a default value, this is dependent on the choice of mapping for primitive types
+const char *value, *QName;
+if (element.default_)
+{ value = element.default_;
+QName = element.default__;
+}
+else
+{ value = element.fixed;
+QName = element.fixed_;
+}
+if (type)
+{ const char *t = tname(NULL, typeURI?typeURI:URI, type);
+if (!strncmp(t, "unsigned ", 9))
+t += 9;
+else if (!strncmp(t, "xsd__unsigned", 13))
+t += 13;
+else if (!strncmp(t, "xsd__", 5))
+t += 5;
+if (!strcmp(t, "bool")
+|| !strcmp(t, "byte")
+|| !strcmp(t, "Byte")
+|| !strcmp(t, "char")
+|| !strcmp(t, "double")
+|| !strcmp(t, "float")
+|| !strcmp(t, "int")
+|| !strcmp(t, "Int")
+|| !strcmp(t, "long")
+|| !strcmp(t, "Long")
+|| !strcmp(t, "LONG64")
+|| !strcmp(t, "short")
+|| !strcmp(t, "Short")
+|| !strcmp(t, "ULONG64"))
+fprintf(stream, " = %s", value);
+else if (!strncmp(t, "enum ", 5))
+{ const char *s;
+if (is_integer(value))
+fprintf(stream, " = %s", value);
+else if (!*value)
+fprintf(stream, " = 0");
+else if ((s = enames[Pair(t + 5, value)]))
+fprintf(stream, " = %s", s);
+}
+else if (!strcmp(t, "char*")
+|| !strcmp(t, "char *")	// not elegant
+|| !strcmp(t, "std::string")
+|| !strcmp(t, "std::string*")
+|| !strcmp(t, "std::string *"))	// not elegant
+fprintf(stream, " = \"%s\"", cstring(value));
+else if (!strcmp(t, "xsd__QName") && QName)	// QName
+fprintf(stream, " = \"%s\"", cstring(QName));
+}
+if (element.default_)
+fprintf(stream, ";\t///< Default value=\"%s\".\n", value);
+else
+fprintf(stream, ";\t///< Fixed required value=\"%s\".\n", value);
+}
+else if (element.nillable)
+fprintf(stream, ";\t///< Nillable pointer.\n");
+else if (!fake_union && (!minOccurs || !strcmp(minOccurs, "1")) && (!maxOccurs || !strcmp(maxOccurs, "1")))
+fprintf(stream, ";\t///< Required element.\n");
+else if (element.fixed)
+fprintf(stream, ";\t///< Fixed optional value=\"%s\".\n", element.fixed);
+else if (!fake_union && minOccurs && !strcmp(minOccurs, "0") && (!maxOccurs || !strcmp(maxOccurs, "1")))
+fprintf(stream, ";\t///< Optional element.\n");
+else
+fprintf(stream, ";\n");
+}
+}
+void Types::gen(const char *URI, const vector<xs__group>& groups)
+{ for (vector<xs__group>::const_iterator group = groups.begin(); group != groups.end(); ++group)
+gen(URI, *group, NULL, NULL);
+}
+void Types::gen(const char *URI, const xs__group& group, const char *minOccurs, const char *maxOccurs)
+{ if (group.minOccurs)
+minOccurs = group.minOccurs;
+if (group.maxOccurs)
+maxOccurs = group.maxOccurs;
+if (group.groupPtr())
+{ if (group.schemaPtr() == group.groupPtr()->schemaPtr())
+gen(URI, *group.groupPtr(), minOccurs, maxOccurs);
+else
+gen(group.groupPtr()->schemaPtr()->targetNamespace, *group.groupPtr(), minOccurs, maxOccurs);
+}
+else
+{ fprintf(stream, "/// GROUP <xs:group name=\"%s\"", group.name ? group.name : "");
+if (minOccurs)
+fprintf(stream, " minOccurs=\"%s\"", minOccurs);
+if (maxOccurs)
+fprintf(stream, " maxOccurs=\"%s\"", maxOccurs);
+fprintf(stream, ">\n");
+document(group.annotation);
+if (group.all)
+gen(URI, *group.all, minOccurs, maxOccurs);
+else if (group.choice)
+gen(URI, NULL, *group.choice, minOccurs, maxOccurs);
+else if (group.sequence)
+gen(URI, *group.sequence, minOccurs, maxOccurs);
+fprintf(stream, "//  END OF GROUP\n");
+}
+}
+void Types::gen(const char *URI, const char *name, const xs__seqchoice& choice, const char *minOccurs, const char *maxOccurs)
+{ const char *r = NULL, *s = NULL, *t = NULL;
+bool use_union = !uflag;
+bool wrap_union = false;
+bool tmp_union;
+if (!URI && choice.schemaPtr())
+URI = choice.schemaPtr()->targetNamespace;
+fprintf(stream, "/// CHOICE <xs:choice");
+if (choice.minOccurs)
+minOccurs = choice.minOccurs;
+if (choice.maxOccurs)
+maxOccurs = choice.maxOccurs;
+if (minOccurs)
+fprintf(stream, " minOccurs=\"%s\"", minOccurs);
+if (maxOccurs)
+fprintf(stream, " maxOccurs=\"%s\"", maxOccurs);
+fprintf(stream, ">\n");
+document(choice.annotation);
+for (vector<xs__contents>::const_iterator c1 = choice.__contents.begin(); c1 != choice.__contents.end(); ++c1)
+{ if ((*c1).__union == SOAP_UNION_xs__union_content_group
+|| (*c1).__union == SOAP_UNION_xs__union_content_sequence)
+{ fprintf(stream, "/// Note: <xs:choice> with embedded <xs:sequence> or <xs:group> prevents the use of a union\n");
+use_union = false;
+break;
+}
+}
+if (use_union && (cflag || sflag))
+{ for (vector<xs__contents>::const_iterator c2 = choice.__contents.begin(); c2 != choice.__contents.end(); ++c2)
+{ if ((*c2).__union == SOAP_UNION_xs__union_content_element
+&& (*c2).__content.element
+&& (*c2).__content.element->maxOccurs
+&& strcmp((*c2).__content.element->maxOccurs, "1"))
+{ fprintf(stream, "/// Note: <xs:choice> of element with maxOccurs>1 prevents the use of a union\n");
+use_union = false;
+break;
+}
+}
+}
+t = uname(URI);
+s = strstr(t, "__union");
+if (s)
+r = s + 7;
+if (!r || !*r)
+{ r = t;
+s = "__union";
+}
+if (maxOccurs && strcmp(maxOccurs, "1"))
+{ if (with_union)
+{ // Generate a wrapper when we need a union within a union
+wrap_union = true;
+fprintf(stream, "    struct __%s\n    {\n", t);
+}
+fprintf(stream, sizeformat, "int", r);
+fprintf(stream, " %s", minOccurs ? minOccurs : "0");
+if (is_integer(maxOccurs))
+fprintf(stream, ":%s", maxOccurs);
+fprintf(stream, ";\n");
+if (cflag)
+fprintf(stream, "    struct _%s\n    {\n", t);
+else
+fprintf(stream, "    class _%s\n    {\n", t);
+}
+if (use_union)
+{ if (!with_union || wrap_union)
+{ fprintf(stream, choiceformat, "int", r);
+if (minOccurs)
+fprintf(stream, " %s", minOccurs);
+fprintf(stream, ";\t///< Union %s selector: set to SOAP_UNION_%s_<fieldname>%s\n", t, t, minOccurs && !strcmp(minOccurs, "0") ? " or 0" : "");
+if (name)
+fprintf(stream, "/// Union for choice in type %s\n", cname(NULL, URI, name));
+fprintf(stream, "    union %s\n    {\n", t);
+}
+tmp_union = with_union;
+with_union = true;
+}
+else
+{ tmp_union = fake_union;
+fake_union = true;
+}
+gen(URI, choice.__contents);
+if (use_union)
+{ with_union = tmp_union;
+if (!with_union || wrap_union)
+fprintf(stream, elementformat, "}", s+2);
+}
+else
+fake_union = tmp_union;
+if (maxOccurs && strcmp(maxOccurs, "1"))
+{ if (use_union)
+fprintf(stream, ";\n");
+fprintf(stream, pointerformat, "}", s);
+}
+fprintf(stream, ";\n");
+if (wrap_union)
+{ fprintf(stream, elementformat, "}", s);
+fprintf(stream, ";\n");
+}
+fprintf(stream, "//  END OF CHOICE\n");
+}
+void Types::gen(const char *URI, const vector<xs__any>& anys)
+{ for (vector<xs__any>::const_iterator any = anys.begin(); any != anys.end(); ++any)
+gen(URI, *any, NULL, NULL);
+}
+void Types::gen(const char *URI, const xs__any& any, const char *minOccurs, const char *maxOccurs)
+{ fprintf(stream, "/// TODO: <any");
+if (any.namespace_)
+fprintf(stream, " namespace=\"%s\"", any.namespace_);
+if (any.minOccurs)
+minOccurs = any.minOccurs;
+if (any.maxOccurs)
+maxOccurs = any.maxOccurs;
+if (minOccurs)
+fprintf(stream, " minOccurs=\"%s\"", minOccurs);
+if (maxOccurs)
+fprintf(stream, " maxOccurs=\"%s\"", maxOccurs);
+fprintf(stream, ">\n/// TODO: Schema extensibility is user-definable.\n///       Consult the protocol documentation to change or insert declarations.\n///       Use wsdl2h option -x to remove this element.\n///       Use wsdl2h option -d for xsd__anyType DOM (soap_dom_element).\n");
+if (!xflag)
+{ if (maxOccurs && strcmp(maxOccurs, "1"))
+{ fprintf(stream, "/// Size of the array of XML or DOM nodes is %s..%s\n", minOccurs ? minOccurs : "1", maxOccurs);
+if (cflag || sflag)
+{ if (!with_union)
+{ fprintf(stream, sizeformat, "int", "");
+fprintf(stream, "0;\n");
+fprintf(stream, elementformat, pname(true, NULL, NULL, "xsd:any"), "__any");
+}
+else
+fprintf(stream, elementformat, tname(NULL, NULL, "xsd:any"), "__any");
+}
+else if (with_union)
+fprintf(stream, pointervectorformat, tname(NULL, NULL, "xsd:any"), "__any");
+else
+fprintf(stream, vectorformat, tname(NULL, NULL, "xsd:any"), "__any");
+}
+else
+fprintf(stream, elementformat, pname(with_union, NULL, NULL, "xsd:any"), "__any");
+if (dflag)
+fprintf(stream, "0;\t///< Catch any element content in DOM.\n");
+else
+fprintf(stream, "0;\t///< Catch any element content in XML string.\n");
+}
+}
+void Types::gen(const char *URI, const xs__anyAttribute& anyAttribute)
+{ if (anyAttribute.namespace_)
+fprintf(stream, "/// <anyAttribute namespace=\"%s\">\n", anyAttribute.namespace_);
+fprintf(stream, "/// TODO: Schema extensibility is user-definable.\n///       Consult the protocol documentation to change or insert declarations.\n///       Use wsdl2h option -x to remove this attribute.\n///       Use wsdl2h option -d for xsd__anyAttribute DOM (soap_dom_attribute).\n");
+if (!xflag)
+{ const char *t = tname(NULL, NULL, "xsd:anyAttribute");
+fprintf(stream, attributeformat, t, "__anyAttribute");
+if (dflag)
+fprintf(stream, ";\t///< Store anyAttribute content in DOM soap_dom_attribute linked node structure.\n");
+else
+fprintf(stream, ";\t///< A placeholder that has no effect: please see comment.\n");
+}
+}
+void Types::gen_inh(const char *URI, const xs__complexType *complexType, bool anonymous)
+{ const xs__complexType *p = complexType;
+if (!p)
+return;
+const char *pURI;
+if (p->schemaPtr())
+pURI = p->schemaPtr()->targetNamespace;
+else
+pURI = URI;
+const char *b = cname(NULL, pURI, p->name);
+if (p->complexContent && p->complexContent->extension)
+gen_inh(URI, p->complexContent->extension->complexTypePtr(), anonymous);
+if (cflag || fflag || anonymous)
+fprintf(stream, "/// INHERITED FROM %s:\n", b);
+else if (comment_nest == 0)
+fprintf(stream, "/*  INHERITED FROM %s:\n", b);
+else
+fprintf(stream, "    INHERITED FROM %s:\n", b);
+comment_nest++;
+if (cflag || fflag)
+pURI = URI; // if base ns != derived ns then qualify elts
+if (p->complexContent && p->complexContent->extension)
+{ if (p->complexContent->extension->group)
+gen(pURI, *p->complexContent->extension->group, NULL, NULL);
+if (p->complexContent->extension->all)
+gen(pURI, *p->complexContent->extension->all, NULL, NULL);
+if (p->complexContent->extension->sequence)
+gen(pURI, *p->complexContent->extension->sequence, NULL, NULL);
+if (p->complexContent->extension->choice)
+gen(pURI, p->name, *p->complexContent->extension->choice, NULL, NULL);
+gen(pURI, p->complexContent->extension->attribute);
+gen(pURI, p->complexContent->extension->attributeGroup);
+if (p->complexContent->extension->anyAttribute)
+gen(pURI, *p->complexContent->extension->anyAttribute);
+}
+else
+{ if (p->all)
+gen(pURI, p->all->element, NULL, NULL);
+else if (p->all)
+gen(pURI, *p->all, NULL, NULL);
+else if (p->choice)
+gen(pURI, p->name, *p->choice, NULL, NULL);
+else if (p->sequence)
+gen(pURI, *p->sequence, NULL, NULL);
+else if (p->any)
+gen(pURI, *p->any, NULL, NULL);
+gen(pURI, p->attribute);
+gen(pURI, p->attributeGroup);
+if (p->anyAttribute)
+gen(pURI, *p->anyAttribute);
+}
+modify(b);
+comment_nest--;
+if (cflag || fflag || anonymous)
+fprintf(stream, "//  END OF INHERITED FROM %s\n", b);
+else if (comment_nest == 0)
+fprintf(stream, "    END OF INHERITED FROM %s */\n", b);
+else
+fprintf(stream, "    END OF INHERITED FROM %s\n", b);
+}
+void Types::gen_soap_array(const char *name, const char *t, const char *item, const char *type)
+{ char *tmp = NULL, *dims = NULL, size[8];
+if (type)
+{ tmp = (char*)emalloc(strlen(type) + 1);
+strcpy(tmp, type);
+}
+*size = '\0';
+if (tmp)
+dims = strrchr(tmp, '[');
+if (dims)
+*dims++ = '\0';
+fprintf(stream, "/// SOAP encoded array of %s\n", tmp ? tmp : "xs:anyType");
+if (cflag)
+fprintf(stream, "struct %s\n{\n", t);
+else if (pflag)
+fprintf(stream, "class %s : public xsd__anyType\n{ public:\n", t);
+else
+fprintf(stream, "class %s\n{ public:\n", t);
+if (dims)
+{ char *s = strchr(dims, ']');
+if (s && s != dims)
+sprintf(size, "[%d]", (int)(s - dims + 1));
+}
+if (tmp)
+{ if (strchr(tmp, '[') != NULL)
+{ gen_soap_array(NULL, "", item, tmp);
+fprintf(stream, arrayformat, "}", item ? aname(NULL, NULL, item) : "");
+fprintf(stream, ";\n");
+}
+else
+{ const char *s = pname(!is_basetype(NULL, NULL, tmp), NULL, NULL, tmp);
+fprintf(stream, "/// Pointer to array of %s.\n", s);
+fprintf(stream, arrayformat, s, item ? aname(NULL, NULL, item) : "");
+fprintf(stream, ";\n");
+}
+if (*size)
+fprintf(stream, "/// Size of the multidimensional dynamic array with dimensions=%s\n", size);
+else
+fprintf(stream, "/// Size of the dynamic array.\n");
+fprintf(stream, arraysizeformat, "int", size);
+fprintf(stream, ";\n/// Offset for partially transmitted arrays (uncomment only when required).\n");
+fprintf(stream, arrayoffsetformat, "int", size);
+fprintf(stream, ";\n");
+}
+else
+{ // TODO: how to handle generic SOAP array? E.g. as an array of anyType?
+fprintf(stream, "// TODO: add declarations to handle generic SOAP-ENC:Array (array of anyType)\n");
+}
+}
+void Types::gen_substitutions(const char *URI, const xs__element &element)
+{ const std::vector<xs__element*> *substitutions;
+const char *name;
+const char *r = NULL, *s = NULL;
+bool use_union = !uflag;
+bool wrap_union = false;
+bool tmp_union;
+bool abstract = false;
+if (!URI && element.schemaPtr())
+URI = element.schemaPtr()->targetNamespace;
+if (element.elementPtr())
+{ name = element.elementPtr()->name;
+substitutions = element.elementPtr()->substitutionsPtr();
+abstract = element.elementPtr()->abstract;
+if (!abstract && element.elementPtr()->complexTypePtr())
+abstract = element.elementPtr()->complexTypePtr()->abstract;
+}
+else
+{ name = element.name;
+substitutions = element.substitutionsPtr();
+abstract = element.abstract;
+if (!abstract && element.complexTypePtr())
+abstract = element.complexTypePtr()->abstract;
+}
+fprintf(stream, "/// CHOICE OF SUBSTITUTIONS <xs:element substitutionGroup=\"%s\"", name);
+if (element.minOccurs)
+fprintf(stream, " minOccurs=\"%s\"", element.minOccurs);
+if (element.maxOccurs)
+fprintf(stream, " maxOccurs=\"%s\"", element.maxOccurs);
+fprintf(stream, "> with elements");
+for (std::vector<xs__element*>::const_iterator i1 = substitutions->begin(); i1 != substitutions->end(); ++i1)
+fprintf(stream, " <%s>", (*i1)->name);
+fprintf(stream, "\n");
+if (use_union)
+{ const char *t = uname(URI);
+// TODO: could reuse the union instead of generating a new one each time!
+s = strstr(t, "__union");
+if (!s)
+s = "__union";
+r = aname(NULL, NULL, name);
+if (element.maxOccurs && strcmp(element.maxOccurs, "1"))
+{ if (with_union)
+{ // Generate a wrapper when we need a union within a union
+wrap_union = true;
+fprintf(stream, "    struct __%s\n    {\n", t);
+}
+fprintf(stream, sizeformat, "int", r);
+fprintf(stream, " %s", element.minOccurs ? element.minOccurs : "0");
+if (is_integer(element.maxOccurs))
+fprintf(stream, ":%s", element.maxOccurs);
+fprintf(stream, ";\n");
+if (cflag)
+fprintf(stream, "    struct _%s\n    {\n", t);
+else
+fprintf(stream, "    class _%s\n    {\n", t);
+}
+if (!with_union || wrap_union)
+{ fprintf(stream, choiceformat, "int", r);
+fprintf(stream, " %s", element.minOccurs ? element.minOccurs : "0");
+fprintf(stream, ";\t///< Union %s selector: set to SOAP_UNION_%s_<fieldname>%s\n", t, t, element.minOccurs && !strcmp(element.minOccurs, "0") ? " or 0" : "");
+fprintf(stream, "/// Union for substitutionGroup=\"%s\"\n", name);
+fprintf(stream, "    union %s\n    {\n", t);
+}
+tmp_union = with_union;
+with_union = true;
+}
+else
+{ tmp_union = fake_union;
+fake_union = true;
+}
+if (!abstract)
+gen(URI, element, false, NULL, NULL);
+for (vector<xs__element*>::const_iterator i2 = substitutions->begin(); i2 != substitutions->end(); ++i2)
+gen(URI, *(*i2), true, NULL, NULL); // substitutions are recursive?
+if (use_union)
+{ with_union = tmp_union;
+if (!with_union || wrap_union)
+{ fprintf(stream, elementformat, "}", s);
+fprintf(stream, ";\n");
+}
+if (element.maxOccurs && strcmp(element.maxOccurs, "1"))
+{ fprintf(stream, ";\n");
+fprintf(stream, pointerformat, "}", s);
+fprintf(stream, ";\n");
+}
+if (wrap_union)
+{ fprintf(stream, elementformat, "}", s);
+fprintf(stream, ";\n");
+}
+}
+else
+fake_union = tmp_union;
+fprintf(stream, "//  END OF CHOICE OF SUBSTITUTIONS\n");
+}
+void Types::document(const xs__annotation *annotation)
+{ if (annotation && annotation->documentation)
+{ fprintf(stream, "/// @brief");
+documentation(annotation->documentation);
+}
+}
+void Types::modify(const char *name)
+{ // TODO: consider support removal of elements/attributes with ns__X = $- Y
+const char *s = modtypemap[name];
+if (s)
+{ while (*s)
+{ if (*s++ == '$')
+fprintf(stream, "/// Member declared in %s\n   ", mapfile);
+s = format(s);
+}
+}
+}
+const char* Types::format(const char *text)
+{ const char *s = text;
+if (!s)
+return NULL;
+while (*s && *s != '$')
+{ if (*s == '\\')
+{ switch (s[1])
+{ case 'n':
+fputc('\n', stream);
+break;
+case 't':
+fputc('\t', stream);
+break;
+default:
+fputc(s[1], stream);
+}
+s++;
+}
+else
+fputc(*s, stream);
+s++;
+}
+fputc('\n', stream);
+return s;
+}
+////////////////////////////////////////////////////////////////////////////////
+//
+//	Type map file parsing
+//
+////////////////////////////////////////////////////////////////////////////////
+static char *getline(char *s, size_t n, FILE *fd)
+{ int c;
+char *t = s;
+if (n)
+n--;
+for (;;)
+{ c = fgetc(fd);
+if (c == '\r')
+continue;
+if (c == '\\')
+{ c = fgetc(fd);
+if (c == '\r')
+c = fgetc(fd);
+if (c < ' ')
+continue;
+if (n)
+{ *t++ = '\\';
+n--;
+}
+}
+if (c == '\n' || c == EOF)
+break;
+if (n)
+{ *t++ = c;
+n--;
+}
+}
+*t++ = '\0';
+if (!*s && c == EOF)
+return NULL;
+return s;
+}
+static const char *nonblank(const char *s)
+{ while (*s && isspace(*s))
+s++;
+return s;
+}
+static const char *fill(char *t, int n, const char *s, int e)
+{ int i = n;
+s = nonblank(s);
+while (*s && *s != e && --i)
+*t++ = *s++;
+while (*s && *s != e)
+s++;
+if (*s)
+s++;
+i = n - i;
+if (i == 0)
+*t = '\0';
+else
+{ while (isspace(*--t) && i--)
+;
+t[1] = '\0';
+}
+return s;
+}
+////////////////////////////////////////////////////////////////////////////////
+//
+//	Miscellaneous
+//
+////////////////////////////////////////////////////////////////////////////////
+static const char *utf8(char *t, const char *s)
+{ unsigned int c = 0;
+unsigned int c1, c2, c3, c4;
+c = (unsigned char)*s;
+if (c >= 0x80)
+{ c1 = (unsigned char)*++s;
+if (c1 < 0x80)
+s--;
+else
+{ c1 &= 0x3F;
+if (c < 0xE0)
+c = ((c & 0x1F) << 6) | c1;
+else
+{ c2 = (unsigned char)*++s & 0x3F;
+if (c < 0xF0)
+c = ((c & 0x0F) << 12) | (c1 << 6) | c2;
+else
+{ c3 = (unsigned char)*++s & 0x3F;
+if (c < 0xF8)
+c = ((c & 0x07) << 18) | (c1 << 12) | (c2 << 6) | c3;
+else
+{ c4 = (unsigned char)*++s & 0x3F;
+if (c < 0xFC)
+c = ((c & 0x03) << 24) | (c1 << 18) | (c2 << 12) | (c3 << 6) | c4;
+else
+c = ((c & 0x01) << 30) | (c1 << 24) | (c2 << 18) | (c3 << 12) | (c4 << 6) | (*++s & 0x3F);
+}
+}
+}
+}
+}
+sprintf(t, "_x%.4x", c);
+return s;
+}
+static const char *cstring(const char *s)
+{ size_t n;
+char *t;
+const char *r;
+for (n = 0, r = s; *r; n++, r++)
+if (*r == '"' || *r == '\\')
+n++;
+else if (*r < 32)
+n += 3;
+r = t = (char*)emalloc(n + 1);
+for (; *s; s++)
+{ if (*s == '"' || *s == '\\')
+{ *t++ = '\\';
+*t++ = *s;
+}
+else if (*s < 32)
+{ sprintf(t, "\\%03o", (unsigned int)(unsigned char)*s);
+t += 4;
+}
+else
+*t++ = *s;
+}
+*t = '\0';
+return r;
+}
+static const char *xstring(const char *s)
+{ size_t n;
+char *t;
+const char *r;
+for (n = 0, r = s; *r; n++, r++)
+{ if (*r < 32 || *r >= 127)
+n += 4;
+else if (*r == '<' || *r == '>')
+n += 3;
+else if (*r == '&')
+n += 4;
+else if (*r == '"')
+n += 5;
+else if (*r == '\\')
+n += 1;
+}
+r = t = (char*)emalloc(n + 1);
+for (; *s; s++)
+{ if (*s < 32 || *s >= 127)
+{ sprintf(t, "&#%.2x;", (unsigned char)*s);
+t += 5;
+}
+else if (*s == '<')
+{ strcpy(t, "&lt;");
+t += 4;
+}
+else if (*s == '>')
+{ strcpy(t, "&gt;");
+t += 4;
+}
+else if (*s == '&')
+{ strcpy(t, "&amp;");
+t += 5;
+}
+else if (*s == '"')
+{ strcpy(t, "&quot;");
+t += 6;
+}
+else if (*s == '\\')
+{ strcpy(t, "\\\\");
+t += 2;
+}
+else
+*t++ = *s;
+}
+*t = '\0';
+return r;
+}
+static LONG64 to_integer(const char *s)
+{ LONG64 n;
+#ifdef HAVE_STRTOLL
+char *r;
+n = soap_strtoll(s, &r, 10);
+#else
+# ifdef HAVE_SSCANF
+sscanf(s, SOAP_LONG_FORMAT, &n);
+# endif
+#endif
+return n;
+}
+static bool is_integer(const char *s)
+{ if ((*s == '-' || *s == '+') && s[1])
+s++;
+if (!*s || strlen(s) > 20)
+return false;
+while (*s && isdigit(*s))
+s++;
+return *s == '\0';
+}
+static void documentation(const char *text)
+{ const char *s = text;
+bool flag = true;
+if (!s)
+return;
+while (*s)
+{ switch (*s)
+{ case '\n':
+case '\t':
+case ' ':
+flag = true;
+break;
+default:
+if (*s > 32)
+{ if (flag)
+{ fputc(' ', stream);
+flag = false;
+}
+fputc(*s, stream);
+}
+}
+s++;
+}
+fputc('\n', stream);
+}
+static void operations(const char *t)
+{ if (!cflag)
+fprintf(stream, "/// class %s operations:\n/// - soap_new_%s(soap*) allocate\n/// - soap_new_%s(soap*, int num) allocate array\n/// - soap_new_req_%s(soap*, ...) allocate, set required members\n/// - soap_new_set_%s(soap*, ...) allocate, set all public members\n/// - int soap_read_%s(soap*, %s*) deserialize from a stream\n/// - int soap_write_%s(soap, %s*) serialize to a stream\n", t, t, t, t, t, t, t, t, t);
+}
+////////////////////////////////////////////////////////////////////////////////
+//
+//	Allocation
+//
+////////////////////////////////////////////////////////////////////////////////
+void *emalloc(size_t size)
+{ void *p = malloc(size);
+if (!p)
+{ fprintf(stderr, "\nError: Malloc failed\n");
+exit(1);
+}
+return p;
+}
+char *estrdup(const char *s)
+{ char *t = (char*)emalloc(strlen(s) + 1);
+strcpy(t, s);
+return t;
+}
+char *estrdupf(const char *s)
+{ char *t = (char*)emalloc(strlen(s) + 1);
+char *p;
+for (p = t; *s; s++)
+{ if (s[0] == '/' && s[1] == '*')
+{ for (s += 2; s[0] && s[1]; s++)
+{ if (s[0] == '*' && s[1] == '/')
+{ s++;
+break;
+}
+}
+continue;
+}
+*p++ = *s;
+}
+*p = '\0';
+return t;
+}

Mercurial > repos > ktnyt > gembassy

comparison GEMBASSY-1.0.3/gsoap/wsdl/types.cpp @ 0:8300eb051bea draft