src/common/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() ||
                 filename.substring(i + 1).toLowerCase() == "html"))
         {
             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;

         StringBuffer buf = new StringBuffer(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

        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() \|\|
	filename.substring(i + 1).toLowerCase() == "html"))
	{
	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;

	StringBuffer buf = new StringBuffer(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

	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);
	}
	}