src/main/java/org/apache/xmlbeans/impl/common/NameUtil.java - xmlbeans - Git at Google

 /*   Copyright 2004 The Apache Software Foundation
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
  *   You may obtain a copy of the License at
  *
  *       http://www.apache.org/licenses/LICENSE-2.0
  *
  *   Unless required by applicable law or agreed to in writing, software
  *   distributed under the License is distributed on an "AS IS" BASIS,
  *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *   See the License for the specific language governing permissions and
  *  limitations under the License.
  */

 package org.apache.xmlbeans.impl.common;

 import javax.xml.namespace.QName;
 import java.util.*;

 public class NameUtil {
     // punctuation characters
     public final static char HYPHEN = '\u002D';
     public final static char PERIOD = '\u002E';
     public final static char COLON = '\u003A';
     public final static char USCORE = '\u005F';
     public final static char DOT = '\u00B7';
     public final static char TELEIA = '\u0387';
     public final static char AYAH = '\u06DD';
     public final static char ELHIZB = '\u06DE';

     private final static boolean DEBUG = false;

     private final static Set javaWords = new HashSet(Arrays.asList(
         new String[]
             {
                 "assert",
                 "abstract",
                 "boolean",
                 "break",
                 "byte",
                 "case",
                 "catch",
                 "char",
                 "class",
                 "const",
                 "continue",
                 "default",
                 "do",
                 "double",
                 "else",
                 "enum", // since JDK1.5
                 "extends",
                 "false", // not a keyword
                 "final",
                 "finally",
                 "float",
                 "for",
                 "goto",
                 "if",
                 "implements",
                 "import",
                 "instanceof",
                 "int",
                 "interface",
                 "long",
                 "native",
                 "new",
                 "null", // not a keyword
                 "package",
                 "private",
                 "protected",
                 "public",
                 "return",
                 "short",
                 "static",
                 "strictfp",
                 "super",
                 "switch",
                 "synchronized",
                 "this",
                 "threadsafe",
                 "throw",
                 "throws",
                 "transient",
                 "true", // not a keyword
                 "try",
                 "void",
                 "volatile",
                 "while",
             }
     ));

     private final static Set extraWords = new HashSet(Arrays.asList(
         new String[]
             {
                 "i",          // used for indexes
                 "target",     // used for parameter
                 "org",        // used for package names
                 "com",        // used for package names
             }
     ));

     /*
     private final static Set javaNames = new HashSet(Arrays.asList(
         new String[]
         {
             "CharSequence",
             "Cloneable",
             "Comparable",
             "Runnable",

             "Boolean",
             "Byte",
             "Character",
             "Class",
             "ClassLoader",
             "Compiler",
             "Double",
             "Float",
             "InheritableThreadLocal",
             "Integer",
             "Long",
             "Math",
             "Number",
             "Object",
             "Package",
             "Process",
             "Runtime",
             "RuntimePermission",
             "SecurityManager",
             "Short",
             "StackTraceElement",
             "StrictMath",
             "String",
             "StringBuffer",
             "System",
             "Thread",
             "ThreadGroup",
             "ThreadLocal",
             "Throwable",
             "Void",

             "ArithmeticException",
             "ArrayIndexOutOfBoundsException",
             "ArrayStoreException",
             "ClassCastException",
             "ClassNotFoundException",
             "CloneNotSupportedException",
             "Exception",
             "IllegalAccessException",
             "IllegalArgumentException",
             "IllegalMonitorStateException",
             "IllegalStateException",
             "IllegalThreadStateException",
             "IndexOutOfBoundsException",
             "InstantiationException",
             "InterruptedException",
             "NegativeArraySizeException",
             "NoSuchFieldException",
             "NoSuchMethodException",
             "NullPointerException",
             "NumberFormatException",
             "RuntimeException",
             "SecurityException",
             "StringIndexOutOfBoundsException",
             "UnsupportedOperationException",

             "AbstractMethodError",
             "AssertionError",
             "ClassCircularityError",
             "ClassFormatError",
             "Error",
             "ExceptionInInitializerError",
             "IllegalAccessError",
             "IncompatibleClassChangeError",
             "InstantiationError",
             "InternalError",
             "LinkageError",
             "NoClassDefFoundError",
             "NoSuchFieldError",
             "NoSuchMethodError",
             "OutOfMemoryError",
             "StackOverflowError",
             "ThreadDeath",
             "UnknownError",
             "UnsatisfiedLinkError",
             "UnsupportedClassVersionError",
             "VerifyError",
             "VirtualMachineError",
         }
     ));
     */

     private final static Set javaNames = new HashSet(Arrays.asList(
         new String[]
             {
                 // 1. all the Java.lang classes [1.4.1 JDK].
                 "CharSequence",
                 "Cloneable",
                 "Comparable",
                 "Runnable",

                 "Boolean",
                 "Byte",
                 "Character",
                 "Class",
                 "ClassLoader",
                 "Compiler",
                 "Double",
                 "Float",
                 "InheritableThreadLocal",
                 "Integer",
                 "Long",
                 "Math",
                 "Number",
                 "Object",
                 "Package",
                 "Process",
                 "Runtime",
                 "RuntimePermission",
                 "SecurityManager",
                 "Short",
                 "StackTraceElement",
                 "StrictMath",
                 "String",
                 "StringBuffer",
                 "System",
                 "Thread",
                 "ThreadGroup",
                 "ThreadLocal",
                 "Throwable",
                 "Void",

                 "ArithmeticException",
                 "ArrayIndexOutOfBoundsException",
                 "ArrayStoreException",
                 "ClassCastException",
                 "ClassNotFoundException",
                 "CloneNotSupportedException",
                 "Exception",
                 "IllegalAccessException",
                 "IllegalArgumentException",
                 "IllegalMonitorStateException",
                 "IllegalStateException",
                 "IllegalThreadStateException",
                 "IndexOutOfBoundsException",
                 "InstantiationException",
                 "InterruptedException",
                 "NegativeArraySizeException",
                 "NoSuchFieldException",
                 "NoSuchMethodException",
                 "NullPointerException",
                 "NumberFormatException",
                 "RuntimeException",
                 "SecurityException",
                 "StringIndexOutOfBoundsException",
                 "UnsupportedOperationException",

                 "AbstractMethodError",
                 "AssertionError",
                 "ClassCircularityError",
                 "ClassFormatError",
                 "Error",
                 "ExceptionInInitializerError",
                 "IllegalAccessError",
                 "IncompatibleClassChangeError",
                 "InstantiationError",
                 "InternalError",
                 "LinkageError",
                 "NoClassDefFoundError",
                 "NoSuchFieldError",
                 "NoSuchMethodError",
                 "OutOfMemoryError",
                 "StackOverflowError",
                 "ThreadDeath",
                 "UnknownError",
                 "UnsatisfiedLinkError",
                 "UnsupportedClassVersionError",
                 "VerifyError",
                 "VirtualMachineError",

                 // 2. other classes used as primitive types by xml beans
                 "BigInteger",
                 "BigDecimal",
                 "Enum",
                 "Date",
                 "GDate",
                 "GDuration",
                 "QName",
                 "List",

                 // 3. the top few org.apache.xmlbeans names
                 "XmlObject",
                 "XmlCursor",
                 "XmlBeans",
                 "SchemaType",
             }
     ));

     public static boolean isValidJavaIdentifier(String id) {
         if (id == null) {
             throw new IllegalArgumentException("id cannot be null");
         }

         int len = id.length();
         if (len == 0) {
             return false;
         }

         if (javaWords.contains(id)) {
             return false;
         }

         if (!Character.isJavaIdentifierStart(id.charAt(0))) {
             return false;
         }

         for (int i = 1; i < len; i++) {
             if (!Character.isJavaIdentifierPart(id.charAt(i))) {
                 return false;
             }
         }

         return true;
     }

     public static String getClassNameFromQName(QName qname) {
         return getClassNameFromQName(qname, false);
     }

     public static String getClassNameFromQName(QName qname, boolean useJaxRpcRules) {
         String java_type = upperCamelCase(qname.getLocalPart(), useJaxRpcRules);

         String uri = qname.getNamespaceURI();
         String java_pkg = null;

         java_pkg = getPackageFromNamespace(uri, useJaxRpcRules);

         if (java_pkg != null) {
             return java_pkg + "." + java_type;
         } else {
             return java_type;
         }
     }

     private static final String JAVA_NS_PREFIX = "java:";
     private static final String LANG_PREFIX = "java.";

     public static String getNamespaceFromPackage(final Class clazz) {
         Class curr_clazz = clazz;

         while (curr_clazz.isArray()) {
             curr_clazz = curr_clazz.getComponentType();
         }

         String fullname = clazz.getName();
         int lastdot = fullname.lastIndexOf('.');
         String pkg_name = lastdot < 0 ? "" : fullname.substring(0, lastdot);

         //special case for builtin types
         /*
         if (curr_clazz.isPrimitive())
         {
             pkg_name = c.getJavaLanguageNamespaceUri();
         }
         else if (pkg_name.startsWith(LANG_PREFIX))
         {
             final String rem_str = pkg_name.substring(LANG_PREFIX.length());
             pkg_name = c.getJavaLanguageNamespaceUri() + "." + rem_str;
         }
         */
         return JAVA_NS_PREFIX + pkg_name;
     }

     private static boolean isUriSchemeChar(char ch) {
         return (ch >= 'a' && ch <= 'z' ||
                 ch >= 'A' && ch <= 'Z' ||
                 ch >= '0' && ch <= '9' ||
                 ch == '-' || ch == '.' || ch == '+');
     }

     private static boolean isUriAlphaChar(char ch) {
         return (ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z');
     }

     private static int findSchemeColon(String uri) {
         int len = uri.length();
         if (len == 0) {
             return -1;
         }
         if (!isUriAlphaChar(uri.charAt(0))) {
             return -1;
         }
         int i;
         for (i = 1; i < len; i++) {
             if (!isUriSchemeChar(uri.charAt(i))) {
                 break;
             }
         }
         if (i == len) {
             return -1;
         }
         if (uri.charAt(i) != ':') {
             return -1;
         }
         // consume consecutive colons
         for (; i < len; i++) {
             if (uri.charAt(i) != ':') {
                 break;
             }
         }
         // for the "scheme:::" case, return len-1
         return i - 1;
     }

     private static String jls77String(String name) {
         StringBuilder buf = new StringBuilder(name);
         for (int i = 0; i < name.length(); i++) {
             // We need to also make sure that our package names don't contain the
             // "$" character in them, which, although a valid Java identifier part,
             // would create confusion when trying to generate fully-qualified names
             if (!Character.isJavaIdentifierPart(buf.charAt(i)) || '$' == buf.charAt(i)) {
                 buf.setCharAt(i, '_');
             }
         }
         if (buf.length() == 0 || !Character.isJavaIdentifierStart(buf.charAt(0))) {
             buf.insert(0, '_');
         }
         if (isJavaReservedWord(name)) {
             buf.append('_');
         }
         return buf.toString();
     }

     private static List splitDNS(String dns) {
         // JAXB says: only split+reverse DNS if TLD matches known TLDs or ISO 3166
         // We are ignoring this now (TH)

         List result = new ArrayList();

         int end = dns.length();
         int begin = dns.lastIndexOf('.');
         for (; begin != -1; begin--) {
             if (dns.charAt(begin) == '.') {
                 result.add(jls77String(dns.substring(begin + 1, end)));
                 end = begin;
             }
         }
         result.add(jls77String(dns.substring(0, end)));

         // JAXB draft example implies removal of www
         if (result.size() >= 3 &&
             ((String) result.get(result.size() - 1)).toLowerCase().equals("www")) {
             result.remove(result.size() - 1);
         }

         return result;
     }

     private static String processFilename(String filename) {
         // JAXB says: strip 2 or 3 letter extension or ".html"

         int i = filename.lastIndexOf('.');
         if (i > 0 && (
             i + 1 + 2 == filename.length() ||
             i + 1 + 3 == filename.length() ||
             "html".equals(filename.substring(i + 1).toLowerCase()))) {
             return filename.substring(0, i);
         }

         return filename;
     }

     public static String getPackageFromNamespace(String uri) {
         return getPackageFromNamespace(uri, false);
     }

     public static String getPackageFromNamespace(String uri, boolean useJaxRpcRules) {
         // special case: no namespace -> package "noNamespace"
         if (uri == null || uri.length() == 0) {
             return "noNamespace";
         }

         // apply draft JAXB rules
         int len = uri.length();
         int i = findSchemeColon(uri);
         List result = null;

         if (i == len - 1) {
             // XMLBEANS-57: colon is at end so just use scheme as the package name
             result = new ArrayList();
             result.add(uri.substring(0, i));
         } else if (i >= 0 && uri.substring(0, i).equals("java")) {
             result = Arrays.asList(uri.substring(i + 1).split("\\."));
         } else {
             result = new ArrayList();
             outer:
             for (i = i + 1; i < len; ) {
                 while (uri.charAt(i) == '/') {
                     if (++i >= len) {
                         break outer;
                     }
                 }
                 int start = i;
                 while (uri.charAt(i) != '/') {
                     if (++i >= len) {
                         break;
                     }
                 }
                 int end = i;
                 result.add(uri.substring(start, end));
             }
             if (result.size() > 1) {
                 result.set(result.size() - 1, processFilename((String) result.get(result.size() - 1)));
             }

             if (result.size() > 0) {
                 List splitdns = splitDNS((String) result.get(0));
                 result.remove(0);
                 result.addAll(0, splitdns);
             }
         }

         StringBuilder buf = new StringBuilder();
         for (Iterator it = result.iterator(); it.hasNext(); ) {
             String part = nonJavaKeyword(lowerCamelCase((String) it.next(), useJaxRpcRules, true));
             if (part.length() > 0) {
                 buf.append(part);
                 buf.append('.');
             }
         }
         if (buf.length() == 0) {
             return "noNamespace";
         }
         if (useJaxRpcRules) {
             return buf.substring(0, buf.length() - 1).toLowerCase();
         }
         return buf.substring(0, buf.length() - 1); // chop off extra dot
     }

     public static void main(String[] args) {
         for (int i = 0; i < args.length; i++) {
             System.out.println(upperCaseUnderbar(args[i]));
         }
     }

     /**
      * Returns a upper-case-and-underbar string using the JAXB rules.
      * Always starts with a capital letter that is a valid
      * java identifier start. (If JAXB rules don't produce
      * one, then "X_" is prepended.)
      */
     public static String upperCaseUnderbar(String xml_name) {
         StringBuilder buf = new StringBuilder();
         List words = splitWords(xml_name, false);

         final int sz = words.size() - 1;
         if (sz >= 0 && !Character.isJavaIdentifierStart(((String) words.get(0)).charAt(0))) {
             buf.append("X_");
         }

         for (int i = 0; i < sz; i++) {
             buf.append((String) words.get(i));
             buf.append(USCORE);
         }

         if (sz >= 0) {
             buf.append((String) words.get(sz));
         }

         //upcase entire buffer
         final int len = buf.length();
         for (int j = 0; j < len; j++) {
             char c = buf.charAt(j);
             buf.setCharAt(j, Character.toUpperCase(c));
         }

         return buf.toString();
     }

     /**
      * Returns a camel-cased string using the JAXB rules.
      * Always starts with a capital letter that is a valid
      * java identifier start. (If JAXB rules don't produce
      * one, then "X" is prepended.)
      */
     public static String upperCamelCase(String xml_name) {
         return upperCamelCase(xml_name, false);
     }

     /**
      * Returns a camel-cased string, but either JAXB or JAX-RPC rules
      * are used
      */
     public static String upperCamelCase(String xml_name, boolean useJaxRpcRules) {
         StringBuilder buf = new StringBuilder();
         List words = splitWords(xml_name, useJaxRpcRules);

         if (words.size() > 0) {
             if (!Character.isJavaIdentifierStart(((String) words.get(0)).charAt(0))) {
                 buf.append("X");
             }

             Iterator itr = words.iterator();
             while (itr.hasNext()) {
                 buf.append((String) itr.next());
             }
         }
         return buf.toString();
     }

     /**
      * Returns a camel-cased string using the JAXB rules,
      * where the first component is lowercased. Note that
      * if the first component is an acronym, the whole
      * thigns gets lowercased.
      * Always starts with a lowercase letter that is a valid
      * java identifier start. (If JAXB rules don't produce
      * one, then "x" is prepended.)
      */
     public static String lowerCamelCase(String xml_name) {
         return lowerCamelCase(xml_name, false, true);
     }

     /**
      * Returns a camel-cased string using the JAXB or JAX-RPC rules
      */
     public static String lowerCamelCase(String xml_name, boolean useJaxRpcRules,
                                         boolean fixGeneratedName) {
         StringBuilder buf = new StringBuilder();
         List words = splitWords(xml_name, useJaxRpcRules);

         if (words.size() > 0) {
             String first = ((String) words.get(0)).toLowerCase();
             char f = first.charAt(0);
             if (!Character.isJavaIdentifierStart(f) && fixGeneratedName) {
                 buf.append("x");
             }
             buf.append(first);

             Iterator itr = words.iterator();
             itr.next(); // skip already-lowercased word
             while (itr.hasNext()) {
                 buf.append((String) itr.next());
             }
         }
         return buf.toString();
     }

     public static String upperCaseFirstLetter(String s) {
         if (s.length() == 0 || Character.isUpperCase(s.charAt(0))) {
             return s;
         }

         StringBuilder buf = new StringBuilder(s);
         buf.setCharAt(0, Character.toUpperCase(buf.charAt(0)));
         return buf.toString();
     }


     /**
      * split an xml name into words via JAXB approach, upcasing first
      * letter of each word as needed, if upcase is true
      * <p>
      * ncname is xml ncname (i.e. no colons).
      */
     private static void addCapped(List list, String str) {
         if (str.length() > 0) {
             list.add(upperCaseFirstLetter(str));
         }
     }

     public static List splitWords(String name, boolean useJaxRpcRules) {
         List list = new ArrayList();
         int len = name.length();
         int start = 0;
         int prefix = START;
         for (int i = 0; i < len; i++) {
             int current = getCharClass(name.charAt(i), useJaxRpcRules);
             if (prefix != PUNCT && current == PUNCT) {
                 addCapped(list, name.substring(start, i));
                 while ((current = getCharClass(name.charAt(i), useJaxRpcRules)) == PUNCT) {
                     if (++i >= len) {
                         return list;
                     }
                 }
                 start = i;
             } else if ((prefix == DIGIT) != (current == DIGIT) ||
                        (prefix == LOWER && current != LOWER) ||
                        (isLetter(prefix) != isLetter(current))) {
                 addCapped(list, name.substring(start, i));
                 start = i;
             } else if (prefix == UPPER && current == LOWER && i > start + 1) {
                 addCapped(list, name.substring(start, i - 1));
                 start = i - 1;
             }
             prefix = current;
         }
         addCapped(list, name.substring(start));
         return list;
     }

     //char classes
     private final static int START = 0;
     private final static int PUNCT = 1;
     private final static int DIGIT = 2;
     private final static int MARK = 3;
     private final static int UPPER = 4;
     private final static int LOWER = 5;
     private final static int NOCASE = 6;

     public static int getCharClass(char c, boolean useJaxRpcRules) {
         //ordering is important here.
         if (isPunctuation(c, useJaxRpcRules)) {
             return PUNCT;
         } else if (Character.isDigit(c)) {
             return DIGIT;
         } else if (Character.isUpperCase(c)) {
             return UPPER;
         } else if (Character.isLowerCase(c)) {
             return LOWER;
         } else if (Character.isLetter(c)) {
             return NOCASE;
         } else if (Character.isJavaIdentifierPart(c)) {
             return MARK;
         } else {
             return PUNCT; // not covered by JAXB: treat it as punctuation
         }
     }

     private static boolean isLetter(int state) {
         return (state == UPPER
                 || state == LOWER
                 || state == NOCASE);
     }

     public static boolean isPunctuation(char c, boolean useJaxRpcRules) {
         return (c == HYPHEN
                 || c == PERIOD
                 || c == COLON
                 || c == DOT
                 || (c == USCORE && !useJaxRpcRules)
                 || c == TELEIA
                 || c == AYAH
                 || c == ELHIZB);
     }

     /**
      * Intended to be applied to a lowercase-starting identifier that
      * may collide with a Java keyword.  If it does collide, this
      * prepends the letter "x".
      */
     public static String nonJavaKeyword(String word) {
         if (isJavaReservedWord(word)) {
             return 'x' + word;
         }
         return word;
     }

     /**
      * Intended to be applied to a lowercase-starting identifier that
      * may collide with a Java keyword.  If it does collide, this
      * prepends the letter "x".
      */
     public static String nonExtraKeyword(String word) {
         if (isExtraReservedWord(word, true)) {
             return word + "Value";
         }
         return word;
     }

     /**
      * Intended to be applied to an uppercase-starting identifier that
      * may collide with a java.lang.* classname.  If it does collide, this
      * prepends the letter "X".
      */
     public static String nonJavaCommonClassName(String name) {
         if (isJavaCommonClassName(name)) {
             return "X" + name;
         }
         return name;
     }

     private static boolean isJavaReservedWord(String word) {
         return isJavaReservedWord(word, true);
     }

     private static boolean isJavaReservedWord(String word, boolean ignore_case) {
         if (ignore_case) {
             word = word.toLowerCase();
         }
         return javaWords.contains(word);
     }

     private static boolean isExtraReservedWord(String word, boolean ignore_case) {
         if (ignore_case) {
             word = word.toLowerCase();
         }
         return extraWords.contains(word);
     }

     public static boolean isJavaCommonClassName(String word) {
         return javaNames.contains(word);
     }
 }
	/* Copyright 2004 The Apache Software Foundation
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package org.apache.xmlbeans.impl.common;

	import javax.xml.namespace.QName;
	import java.util.*;

	public class NameUtil {
	// punctuation characters
	public final static char HYPHEN = '\u002D';
	public final static char PERIOD = '\u002E';
	public final static char COLON = '\u003A';
	public final static char USCORE = '\u005F';
	public final static char DOT = '\u00B7';
	public final static char TELEIA = '\u0387';
	public final static char AYAH = '\u06DD';
	public final static char ELHIZB = '\u06DE';

	private final static boolean DEBUG = false;

	private final static Set javaWords = new HashSet(Arrays.asList(
	new String[]
	{
	"assert",
	"abstract",
	"boolean",
	"break",
	"byte",
	"case",
	"catch",
	"char",
	"class",
	"const",
	"continue",
	"default",
	"do",
	"double",
	"else",
	"enum", // since JDK1.5
	"extends",
	"false", // not a keyword
	"final",
	"finally",
	"float",
	"for",
	"goto",
	"if",
	"implements",
	"import",
	"instanceof",
	"int",
	"interface",
	"long",
	"native",
	"new",
	"null", // not a keyword
	"package",
	"private",
	"protected",
	"public",
	"return",
	"short",
	"static",
	"strictfp",
	"super",
	"switch",
	"synchronized",
	"this",
	"threadsafe",
	"throw",
	"throws",
	"transient",
	"true", // not a keyword
	"try",
	"void",
	"volatile",
	"while",
	}
	));

	private final static Set extraWords = new HashSet(Arrays.asList(
	new String[]
	{
	"i", // used for indexes
	"target", // used for parameter
	"org", // used for package names
	"com", // used for package names
	}
	));

	/*
	private final static Set javaNames = new HashSet(Arrays.asList(
	new String[]
	{
	"CharSequence",
	"Cloneable",
	"Comparable",
	"Runnable",

	"Boolean",
	"Byte",
	"Character",
	"Class",
	"ClassLoader",
	"Compiler",
	"Double",
	"Float",
	"InheritableThreadLocal",
	"Integer",
	"Long",
	"Math",
	"Number",
	"Object",
	"Package",
	"Process",
	"Runtime",
	"RuntimePermission",
	"SecurityManager",
	"Short",
	"StackTraceElement",
	"StrictMath",
	"String",
	"StringBuffer",
	"System",
	"Thread",
	"ThreadGroup",
	"ThreadLocal",
	"Throwable",
	"Void",

	"ArithmeticException",
	"ArrayIndexOutOfBoundsException",
	"ArrayStoreException",
	"ClassCastException",
	"ClassNotFoundException",
	"CloneNotSupportedException",
	"Exception",
	"IllegalAccessException",
	"IllegalArgumentException",
	"IllegalMonitorStateException",
	"IllegalStateException",
	"IllegalThreadStateException",
	"IndexOutOfBoundsException",
	"InstantiationException",
	"InterruptedException",
	"NegativeArraySizeException",
	"NoSuchFieldException",
	"NoSuchMethodException",
	"NullPointerException",
	"NumberFormatException",
	"RuntimeException",
	"SecurityException",
	"StringIndexOutOfBoundsException",
	"UnsupportedOperationException",

	"AbstractMethodError",
	"AssertionError",
	"ClassCircularityError",
	"ClassFormatError",
	"Error",
	"ExceptionInInitializerError",
	"IllegalAccessError",
	"IncompatibleClassChangeError",
	"InstantiationError",
	"InternalError",
	"LinkageError",
	"NoClassDefFoundError",
	"NoSuchFieldError",
	"NoSuchMethodError",
	"OutOfMemoryError",
	"StackOverflowError",
	"ThreadDeath",
	"UnknownError",
	"UnsatisfiedLinkError",
	"UnsupportedClassVersionError",
	"VerifyError",
	"VirtualMachineError",
	}
	));
	*/

	private final static Set javaNames = new HashSet(Arrays.asList(
	new String[]
	{
	// 1. all the Java.lang classes [1.4.1 JDK].
	"CharSequence",
	"Cloneable",
	"Comparable",
	"Runnable",

	"Boolean",
	"Byte",
	"Character",
	"Class",
	"ClassLoader",
	"Compiler",
	"Double",
	"Float",
	"InheritableThreadLocal",
	"Integer",
	"Long",
	"Math",
	"Number",
	"Object",
	"Package",
	"Process",
	"Runtime",
	"RuntimePermission",
	"SecurityManager",
	"Short",
	"StackTraceElement",
	"StrictMath",
	"String",
	"StringBuffer",
	"System",
	"Thread",
	"ThreadGroup",
	"ThreadLocal",
	"Throwable",
	"Void",

	"ArithmeticException",
	"ArrayIndexOutOfBoundsException",
	"ArrayStoreException",
	"ClassCastException",
	"ClassNotFoundException",
	"CloneNotSupportedException",
	"Exception",
	"IllegalAccessException",
	"IllegalArgumentException",
	"IllegalMonitorStateException",
	"IllegalStateException",
	"IllegalThreadStateException",
	"IndexOutOfBoundsException",
	"InstantiationException",
	"InterruptedException",
	"NegativeArraySizeException",
	"NoSuchFieldException",
	"NoSuchMethodException",
	"NullPointerException",
	"NumberFormatException",
	"RuntimeException",
	"SecurityException",
	"StringIndexOutOfBoundsException",
	"UnsupportedOperationException",

	"AbstractMethodError",
	"AssertionError",
	"ClassCircularityError",
	"ClassFormatError",
	"Error",
	"ExceptionInInitializerError",
	"IllegalAccessError",
	"IncompatibleClassChangeError",
	"InstantiationError",
	"InternalError",
	"LinkageError",
	"NoClassDefFoundError",
	"NoSuchFieldError",
	"NoSuchMethodError",
	"OutOfMemoryError",
	"StackOverflowError",
	"ThreadDeath",
	"UnknownError",
	"UnsatisfiedLinkError",
	"UnsupportedClassVersionError",
	"VerifyError",
	"VirtualMachineError",

	// 2. other classes used as primitive types by xml beans
	"BigInteger",
	"BigDecimal",
	"Enum",
	"Date",
	"GDate",
	"GDuration",
	"QName",
	"List",

	// 3. the top few org.apache.xmlbeans names
	"XmlObject",
	"XmlCursor",
	"XmlBeans",
	"SchemaType",
	}
	));

	public static boolean isValidJavaIdentifier(String id) {
	if (id == null) {
	throw new IllegalArgumentException("id cannot be null");
	}

	int len = id.length();
	if (len == 0) {
	return false;
	}

	if (javaWords.contains(id)) {
	return false;
	}

	if (!Character.isJavaIdentifierStart(id.charAt(0))) {
	return false;
	}

	for (int i = 1; i < len; i++) {
	if (!Character.isJavaIdentifierPart(id.charAt(i))) {
	return false;
	}
	}

	return true;
	}

	public static String getClassNameFromQName(QName qname) {
	return getClassNameFromQName(qname, false);
	}

	public static String getClassNameFromQName(QName qname, boolean useJaxRpcRules) {
	String java_type = upperCamelCase(qname.getLocalPart(), useJaxRpcRules);

	String uri = qname.getNamespaceURI();
	String java_pkg = null;

	java_pkg = getPackageFromNamespace(uri, useJaxRpcRules);

	if (java_pkg != null) {
	return java_pkg + "." + java_type;
	} else {
	return java_type;
	}
	}

	private static final String JAVA_NS_PREFIX = "java:";
	private static final String LANG_PREFIX = "java.";

	public static String getNamespaceFromPackage(final Class clazz) {
	Class curr_clazz = clazz;

	while (curr_clazz.isArray()) {
	curr_clazz = curr_clazz.getComponentType();
	}

	String fullname = clazz.getName();
	int lastdot = fullname.lastIndexOf('.');
	String pkg_name = lastdot < 0 ? "" : fullname.substring(0, lastdot);

	//special case for builtin types
	/*
	if (curr_clazz.isPrimitive())
	{
	pkg_name = c.getJavaLanguageNamespaceUri();
	}
	else if (pkg_name.startsWith(LANG_PREFIX))
	{
	final String rem_str = pkg_name.substring(LANG_PREFIX.length());
	pkg_name = c.getJavaLanguageNamespaceUri() + "." + rem_str;
	}
	*/
	return JAVA_NS_PREFIX + pkg_name;
	}

	private static boolean isUriSchemeChar(char ch) {
	return (ch >= 'a' && ch <= 'z' \|\|
	ch >= 'A' && ch <= 'Z' \|\|
	ch >= '0' && ch <= '9' \|\|
	ch == '-' \|\| ch == '.' \|\| ch == '+');
	}

	private static boolean isUriAlphaChar(char ch) {
	return (ch >= 'a' && ch <= 'z' \|\| ch >= 'A' && ch <= 'Z');
	}

	private static int findSchemeColon(String uri) {
	int len = uri.length();
	if (len == 0) {
	return -1;
	}
	if (!isUriAlphaChar(uri.charAt(0))) {
	return -1;
	}
	int i;
	for (i = 1; i < len; i++) {
	if (!isUriSchemeChar(uri.charAt(i))) {
	break;
	}
	}
	if (i == len) {
	return -1;
	}
	if (uri.charAt(i) != ':') {
	return -1;
	}
	// consume consecutive colons
	for (; i < len; i++) {
	if (uri.charAt(i) != ':') {
	break;
	}
	}
	// for the "scheme:::" case, return len-1
	return i - 1;
	}

	private static String jls77String(String name) {
	StringBuilder buf = new StringBuilder(name);
	for (int i = 0; i < name.length(); i++) {
	// We need to also make sure that our package names don't contain the
	// "$" character in them, which, although a valid Java identifier part,
	// would create confusion when trying to generate fully-qualified names
	if (!Character.isJavaIdentifierPart(buf.charAt(i)) \|\| '$' == buf.charAt(i)) {
	buf.setCharAt(i, '_');
	}
	}
	if (buf.length() == 0 \|\| !Character.isJavaIdentifierStart(buf.charAt(0))) {
	buf.insert(0, '_');
	}
	if (isJavaReservedWord(name)) {
	buf.append('_');
	}
	return buf.toString();
	}

	private static List splitDNS(String dns) {
	// JAXB says: only split+reverse DNS if TLD matches known TLDs or ISO 3166
	// We are ignoring this now (TH)

	List result = new ArrayList();

	int end = dns.length();
	int begin = dns.lastIndexOf('.');
	for (; begin != -1; begin--) {
	if (dns.charAt(begin) == '.') {
	result.add(jls77String(dns.substring(begin + 1, end)));
	end = begin;
	}
	}
	result.add(jls77String(dns.substring(0, end)));

	// JAXB draft example implies removal of www
	if (result.size() >= 3 &&
	((String) result.get(result.size() - 1)).toLowerCase().equals("www")) {
	result.remove(result.size() - 1);
	}

	return result;
	}

	private static String processFilename(String filename) {
	// JAXB says: strip 2 or 3 letter extension or ".html"

	int i = filename.lastIndexOf('.');
	if (i > 0 && (
	i + 1 + 2 == filename.length() \|\|
	i + 1 + 3 == filename.length() \|\|
	"html".equals(filename.substring(i + 1).toLowerCase()))) {
	return filename.substring(0, i);
	}

	return filename;
	}

	public static String getPackageFromNamespace(String uri) {
	return getPackageFromNamespace(uri, false);
	}

	public static String getPackageFromNamespace(String uri, boolean useJaxRpcRules) {
	// special case: no namespace -> package "noNamespace"
	if (uri == null \|\| uri.length() == 0) {
	return "noNamespace";
	}

	// apply draft JAXB rules
	int len = uri.length();
	int i = findSchemeColon(uri);
	List result = null;

	if (i == len - 1) {
	// XMLBEANS-57: colon is at end so just use scheme as the package name
	result = new ArrayList();
	result.add(uri.substring(0, i));
	} else if (i >= 0 && uri.substring(0, i).equals("java")) {
	result = Arrays.asList(uri.substring(i + 1).split("\\."));
	} else {
	result = new ArrayList();
	outer:
	for (i = i + 1; i < len; ) {
	while (uri.charAt(i) == '/') {
	if (++i >= len) {
	break outer;
	}
	}
	int start = i;
	while (uri.charAt(i) != '/') {
	if (++i >= len) {
	break;
	}
	}
	int end = i;
	result.add(uri.substring(start, end));
	}
	if (result.size() > 1) {
	result.set(result.size() - 1, processFilename((String) result.get(result.size() - 1)));
	}

	if (result.size() > 0) {
	List splitdns = splitDNS((String) result.get(0));
	result.remove(0);
	result.addAll(0, splitdns);
	}
	}

	StringBuilder buf = new StringBuilder();
	for (Iterator it = result.iterator(); it.hasNext(); ) {
	String part = nonJavaKeyword(lowerCamelCase((String) it.next(), useJaxRpcRules, true));
	if (part.length() > 0) {
	buf.append(part);
	buf.append('.');
	}
	}
	if (buf.length() == 0) {
	return "noNamespace";
	}
	if (useJaxRpcRules) {
	return buf.substring(0, buf.length() - 1).toLowerCase();
	}
	return buf.substring(0, buf.length() - 1); // chop off extra dot
	}

	public static void main(String[] args) {
	for (int i = 0; i < args.length; i++) {
	System.out.println(upperCaseUnderbar(args[i]));
	}
	}

	/**
	* Returns a upper-case-and-underbar string using the JAXB rules.
	* Always starts with a capital letter that is a valid
	* java identifier start. (If JAXB rules don't produce
	* one, then "X_" is prepended.)
	*/
	public static String upperCaseUnderbar(String xml_name) {
	StringBuilder buf = new StringBuilder();
	List words = splitWords(xml_name, false);

	final int sz = words.size() - 1;
	if (sz >= 0 && !Character.isJavaIdentifierStart(((String) words.get(0)).charAt(0))) {
	buf.append("X_");
	}

	for (int i = 0; i < sz; i++) {
	buf.append((String) words.get(i));
	buf.append(USCORE);
	}

	if (sz >= 0) {
	buf.append((String) words.get(sz));
	}

	//upcase entire buffer
	final int len = buf.length();
	for (int j = 0; j < len; j++) {
	char c = buf.charAt(j);
	buf.setCharAt(j, Character.toUpperCase(c));
	}

	return buf.toString();
	}

	/**
	* Returns a camel-cased string using the JAXB rules.
	* Always starts with a capital letter that is a valid
	* java identifier start. (If JAXB rules don't produce
	* one, then "X" is prepended.)
	*/
	public static String upperCamelCase(String xml_name) {
	return upperCamelCase(xml_name, false);
	}

	/**
	* Returns a camel-cased string, but either JAXB or JAX-RPC rules
	* are used
	*/
	public static String upperCamelCase(String xml_name, boolean useJaxRpcRules) {
	StringBuilder buf = new StringBuilder();
	List words = splitWords(xml_name, useJaxRpcRules);

	if (words.size() > 0) {
	if (!Character.isJavaIdentifierStart(((String) words.get(0)).charAt(0))) {
	buf.append("X");
	}

	Iterator itr = words.iterator();
	while (itr.hasNext()) {
	buf.append((String) itr.next());
	}
	}
	return buf.toString();
	}

	/**
	* Returns a camel-cased string using the JAXB rules,
	* where the first component is lowercased. Note that
	* if the first component is an acronym, the whole
	* thigns gets lowercased.
	* Always starts with a lowercase letter that is a valid
	* java identifier start. (If JAXB rules don't produce
	* one, then "x" is prepended.)
	*/
	public static String lowerCamelCase(String xml_name) {
	return lowerCamelCase(xml_name, false, true);
	}

	/**
	* Returns a camel-cased string using the JAXB or JAX-RPC rules
	*/
	public static String lowerCamelCase(String xml_name, boolean useJaxRpcRules,
	boolean fixGeneratedName) {
	StringBuilder buf = new StringBuilder();
	List words = splitWords(xml_name, useJaxRpcRules);

	if (words.size() > 0) {
	String first = ((String) words.get(0)).toLowerCase();
	char f = first.charAt(0);
	if (!Character.isJavaIdentifierStart(f) && fixGeneratedName) {
	buf.append("x");
	}
	buf.append(first);

	Iterator itr = words.iterator();
	itr.next(); // skip already-lowercased word
	while (itr.hasNext()) {
	buf.append((String) itr.next());
	}
	}
	return buf.toString();
	}

	public static String upperCaseFirstLetter(String s) {
	if (s.length() == 0 \|\| Character.isUpperCase(s.charAt(0))) {
	return s;
	}

	StringBuilder buf = new StringBuilder(s);
	buf.setCharAt(0, Character.toUpperCase(buf.charAt(0)));
	return buf.toString();
	}


	/**
	* split an xml name into words via JAXB approach, upcasing first
	* letter of each word as needed, if upcase is true
	* <p>
	* ncname is xml ncname (i.e. no colons).
	*/
	private static void addCapped(List list, String str) {
	if (str.length() > 0) {
	list.add(upperCaseFirstLetter(str));
	}
	}

	public static List splitWords(String name, boolean useJaxRpcRules) {
	List list = new ArrayList();
	int len = name.length();
	int start = 0;
	int prefix = START;
	for (int i = 0; i < len; i++) {
	int current = getCharClass(name.charAt(i), useJaxRpcRules);
	if (prefix != PUNCT && current == PUNCT) {
	addCapped(list, name.substring(start, i));
	while ((current = getCharClass(name.charAt(i), useJaxRpcRules)) == PUNCT) {
	if (++i >= len) {
	return list;
	}
	}
	start = i;
	} else if ((prefix == DIGIT) != (current == DIGIT) \|\|
	(prefix == LOWER && current != LOWER) \|\|
	(isLetter(prefix) != isLetter(current))) {
	addCapped(list, name.substring(start, i));
	start = i;
	} else if (prefix == UPPER && current == LOWER && i > start + 1) {
	addCapped(list, name.substring(start, i - 1));
	start = i - 1;
	}
	prefix = current;
	}
	addCapped(list, name.substring(start));
	return list;
	}

	//char classes
	private final static int START = 0;
	private final static int PUNCT = 1;
	private final static int DIGIT = 2;
	private final static int MARK = 3;
	private final static int UPPER = 4;
	private final static int LOWER = 5;
	private final static int NOCASE = 6;

	public static int getCharClass(char c, boolean useJaxRpcRules) {
	//ordering is important here.
	if (isPunctuation(c, useJaxRpcRules)) {
	return PUNCT;
	} else if (Character.isDigit(c)) {
	return DIGIT;
	} else if (Character.isUpperCase(c)) {
	return UPPER;
	} else if (Character.isLowerCase(c)) {
	return LOWER;
	} else if (Character.isLetter(c)) {
	return NOCASE;
	} else if (Character.isJavaIdentifierPart(c)) {
	return MARK;
	} else {
	return PUNCT; // not covered by JAXB: treat it as punctuation
	}
	}

	private static boolean isLetter(int state) {
	return (state == UPPER
	\|\| state == LOWER
	\|\| state == NOCASE);
	}

	public static boolean isPunctuation(char c, boolean useJaxRpcRules) {
	return (c == HYPHEN
	\|\| c == PERIOD
	\|\| c == COLON
	\|\| c == DOT
	\|\| (c == USCORE && !useJaxRpcRules)
	\|\| c == TELEIA
	\|\| c == AYAH
	\|\| c == ELHIZB);
	}

	/**
	* Intended to be applied to a lowercase-starting identifier that
	* may collide with a Java keyword. If it does collide, this
	* prepends the letter "x".
	*/
	public static String nonJavaKeyword(String word) {
	if (isJavaReservedWord(word)) {
	return 'x' + word;
	}
	return word;
	}

	/**
	* Intended to be applied to a lowercase-starting identifier that
	* may collide with a Java keyword. If it does collide, this
	* prepends the letter "x".
	*/
	public static String nonExtraKeyword(String word) {
	if (isExtraReservedWord(word, true)) {
	return word + "Value";
	}
	return word;
	}

	/**
	* Intended to be applied to an uppercase-starting identifier that
	* may collide with a java.lang.* classname. If it does collide, this
	* prepends the letter "X".
	*/
	public static String nonJavaCommonClassName(String name) {
	if (isJavaCommonClassName(name)) {
	return "X" + name;
	}
	return name;
	}

	private static boolean isJavaReservedWord(String word) {
	return isJavaReservedWord(word, true);
	}

	private static boolean isJavaReservedWord(String word, boolean ignore_case) {
	if (ignore_case) {
	word = word.toLowerCase();
	}
	return javaWords.contains(word);
	}

	private static boolean isExtraReservedWord(String word, boolean ignore_case) {
	if (ignore_case) {
	word = word.toLowerCase();
	}
	return extraWords.contains(word);
	}

	public static boolean isJavaCommonClassName(String word) {
	return javaNames.contains(word);
	}
	}