types.cpp

一款开源的soap库

  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"] = "";
  usetypemap["SOAP_ENC__int"] = "int";
  deftypemap["SOAP_ENC__long"] = "";
  usetypemap["SOAP_ENC__long"] = "LONG64";
  deftypemap["SOAP_ENC__short"] = "";
  usetypemap["SOAP_ENC__short"] = "short";
  ptrtypemap["SOAP_ENC__short"] = "int*";
  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"] = "";
  usetypemap["SOAP_ENC__unsignedByte"] = "unsigned char";
  ptrtypemap["SOAP_ENC__unsignedByte"] = "unsigned short*";
  deftypemap["SOAP_ENC__unsignedInt"] = "";
  usetypemap["SOAP_ENC__unsignedInt"] = "unsigned long";
  deftypemap["SOAP_ENC__unsignedLong"] = "";
  usetypemap["SOAP_ENC__unsignedLong"] = "ULONG64";
  deftypemap["SOAP_ENC__unsignedShort"] = "";
  usetypemap["SOAP_ENC__unsignedShort"] = "unsigned short";
  deftypemap["SOAP_ENC__Array"] = "";
  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;
}

// 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)
{ char buf[1024], *t;
  const char *p, *s, *name;
  if (!qname)
  { fprintf(stream, "// Warning: internal error, undefined qname in fname()\n");
    if (vflag)
      fprintf(stderr, "Internal error, undefined qname in fname()\n");
    qname = "?";
  }
  s = strrchr(qname, ':');
  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;
    }
  }
  else
    name = qname;
  if (URI)
    p = nsprefix(prefix, URI);
  else if (s)
    p = s;
  else
    p = "";
  if (lookup == LOOKUP)
  { s = qnames[Pair(p,name)];
    if (s)
      return s;
  }
  t = buf;
  if (!prefix || *prefix)
  { s = p;
    // no longer add '_' when URI != NULL, since nsprefix() will do this
    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 != p)
          *t++ = '_';
        else if (*s == '_')
        { if (s == p)
	    *t++ = '_';
	  else 
	  { strcpy(t, "_USCORE");
            t += 7;
	  }
        }
        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 != name)
      *t++ = '_';
    else if (*s == '_')
    { strcpy(t, "_USCORE");
      t += 7;
    }
    else
    { s = utf8(t, s);
      t += 6;
    }
  }
  *t = '\0';
  while (knames.find(buf) != knames.end() || (reserved && reserved->find(buf) != reserved->end()))
  { *t++ = '_';
    *t = '\0';
  }
  if (isalpha(*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;
    /*
    for (MapOfPairToString::const_iterator i = qnames.begin(); i != qnames.end(); ++i)
      cerr << "(" << (*i).first.first << "," << (*i).first.second << ") = " << (*i).second << endl;
    */
  }
  return t;
}

bool Types::is_defined(const char *prefix, const char *URI, const char *qname)
{ const char *t = fname(prefix, URI, qname, NULL, LOOKUP);
  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);
}

const char *Types::cname(const char *prefix, const char *URI, const char *qname)
{ return fname(prefix, URI, qname, NULL, LOOKUP);
}

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];
  else
  { s = t;
    fprintf(stream, "// Warning: internal error, undefined qname '%s' for type '%s'\n", qname?qname:"", t);
    if (vflag)
      fprintf(stderr, "Internal error, undefined qname '%s' for type '%s'\n", qname?qname:"", t);
  }
  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, *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];
      else
      { s = t;
        fprintf(stream, "// Warning: internal error, undefined: %s %s\n", qname, t);
        if (vflag)
          fprintf(stderr, "Internal error, undefined: %s %s\n", qname, t);
      }
      r = s;
      do
      { r = strchr(r + 1, '*');
        if (r && *(r-1) != '/' && *(r+1) != '/')
	  break;
      } while (r);
      if (!r)	// already pointer?
      { char *p = (char*)emalloc(strlen(s) + 2);
        strcpy(p, s);
        strcat(p, "*");
        s = p;
      }
      if (vflag)
        fprintf(stderr, "Mapping pointer to %s to %s\n", t, s);
      ptrtypemap[t] = s;
    }
  }
  else if (usetypemap.find(t) != usetypemap.end())
    s = usetypemap[t];
  else
  { s = t;
    fprintf(stream, "// Warning: internal error, undefined: %s %s\n", qname, t);
    if (vflag)
      fprintf(stderr, "Internal error, undefined: %s %s\n", qname, t);
  }
  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);
  if (deftypemap[t])
  { if (vflag)
      fprintf(stderr, "Name %s already defined (probably in %s file)\n", qname, mapfile);
    return NULL;
  }
  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)
    fprintf(stderr, "Defined %s in namespace %s as %s\n", qname, URI?URI:(prefix?prefix:""), s);
  return t;
}

// get enumeration value. URI/type refers to the enum simpleType.
const char *Types::ename(const char *type, const char *value)
{ const char *s = enames[Pair(type,value)];
  if (!s)
  { s = fname(NULL, NULL, value, &rnames, NOLOOKUP);
    if (!eflag && type && *type)
    { // Add prefix to enum
      char *buf = (char*)emalloc(strlen(type) + strlen(s) + 3);
      if (s[0] == '_' && s[1] != 'x')		// _xXXXX is OK here
        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);
  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);
  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);